@stamhoofd/backend 2.141.0 → 2.143.0

package/src/helpers/ProviderSettlementSyncRunner.ts

@@ -1,3 +1,5 @@
+import type { AbortSignal } from '@stamhoofd/queues';
+
 export type SettlementSyncSummary = {
     feeMonths: number;
     failedFeeMonths: number;
@@ -26,6 +28,12 @@ export type ProviderSyncRunOptions = {
      * Fired after each unit of work (a month for Stripe, an account for Mollie).
      */
     onProgress?: () => void;
+
+    /**
+     * Stops the walk at the next safe point (a restart). Aborting is not a sync failure: it leaves
+     * everything it touched retryable instead of counting or reporting it.
+     */
+    abort: AbortSignal;
 };
 
 /**

package/src/helpers/SettlementExporter.test.ts

@@ -363,4 +363,26 @@ describe('SettlementExporter', () => {
             expect((await exporter.getProviderInvoiceStatus(totals)).check).toBe('');
         });
     });
+
+    describe('getSettlementCheck', () => {
+        const check = (settlement: { amount: number; pendingFees?: number; uncollectibleFees?: number }, rows: { linesTotal: number; chargesTotal: number }) => {
+            return SettlementExporter.getSettlementCheck({ pendingFees: 0, uncollectibleFees: 0, ...settlement } as Settlement, rows);
+        };
+
+        test('a payout its rows fully explain is approved', () => {
+            expect(check({ amount: 49_70_00 }, { linesTotal: 50_00_00, chargesTotal: -30_00 })).toBe('✓');
+        });
+
+        test('a difference the stored rows do not cover is missing data', () => {
+            expect(check({ amount: 49_70_00 }, { linesTotal: 50_00_00, chargesTotal: 0 })).toBe('Ontbrekende gegevens');
+        });
+
+        test('fees still waiting for their invoice explain the rest, and say so', () => {
+            expect(check({ amount: 50_00_00, pendingFees: 30_00 }, { linesTotal: 49_70_00, chargesTotal: 0 })).toBe('Kosten nog niet gefactureerd');
+        });
+
+        test('fees that will never be invoiced explain the rest without waiting for one', () => {
+            expect(check({ amount: 50_00_00, uncollectibleFees: 30_00 }, { linesTotal: 49_70_00, chargesTotal: 0 })).toBe('✓');
+        });
+    });
 });

package/src/helpers/SettlementExporter.ts

@@ -115,6 +115,12 @@ export class SettlementExporter {
      */
     private hasPendingFees = false;
 
+    /**
+     * Same for fees of organizations that no longer exist: they are only ever received by the
+     * platform, and even there they are the exception.
+     */
+    private hasUncollectibleFees = false;
+
     constructor({ start, end, provider, organization, sellingOrganization }: { start: Date; end: Date; provider?: PaymentProvider | null; organization: Organization; sellingOrganization: Organization }) {
         this.start = start;
         this.end = end;
@@ -186,8 +192,9 @@ export class SettlementExporter {
         settlements.sort((a, b) => a.settledAt.getTime() - b.settledAt.getTime() || a.externalId.localeCompare(b.externalId));
 
         // Only the organization that charges application fees ever receives any, so for everyone
-        // else the column would be empty
+        // else the columns would be empty
         this.hasPendingFees = settlements.some(settlement => settlement.pendingFees !== 0);
+        this.hasUncollectibleFees = settlements.some(settlement => settlement.uncollectibleFees !== 0);
 
         await writer.addRow(sheets.settlementsSheet, [
             textCell('Provider', 10),
@@ -202,6 +209,7 @@ export class SettlementExporter {
             textCell('Transacties', 11),
             textCell('Onverklaard', 13),
             ...(this.hasPendingFees ? [textCell('Niet-gefactureerde kosten', 22)] : []),
+            ...(this.hasUncollectibleFees ? [textCell('Niet-aanrekenbare kosten', 22)] : []),
             textCell('Check', 20),
         ]);
 
@@ -241,10 +249,11 @@ export class SettlementExporter {
      * The verdict of one payout: what it paid out has to be explained by its payments and its
      * costs. Fees we received but haven't invoiced yet have no payment line of their own, so they
      * explain their part of the difference until the invoicer creates one — that is missing data,
-     * not a mismatch, and it says so.
+     * not a mismatch, and it says so. Fees of organizations that no longer exist explain their part
+     * the same way, but never get a payment line: they are not waiting for anything.
      */
     static getSettlementCheck(settlement: Settlement, { linesTotal, chargesTotal }: { linesTotal: number; chargesTotal: number }): string {
-        if (settlement.amount - linesTotal - chargesTotal - settlement.pendingFees !== 0) {
+        if (settlement.amount - linesTotal - chargesTotal - settlement.pendingFees - settlement.uncollectibleFees !== 0) {
             return 'Ontbrekende gegevens';
         }
         if (settlement.pendingFees !== 0) {
@@ -270,6 +279,7 @@ export class SettlementExporter {
             { value: settlement.transactionCount },
             currencyCell(settlement.unexplainedAmount),
             ...(this.hasPendingFees ? [currencyCell(settlement.pendingFees)] : []),
+            ...(this.hasUncollectibleFees ? [currencyCell(settlement.uncollectibleFees)] : []),
             textCell(SettlementExporter.getSettlementCheck(settlement, { linesTotal, chargesTotal })),
         ]);
     }

package/src/helpers/SettlementSyncRunner.test.ts

@@ -1,7 +1,9 @@
 import type { Organization } from '@stamhoofd/models';
 import { MolliePayment, OrganizationFactory, Payment } from '@stamhoofd/models';
 import { Settlement } from '@stamhoofd/models/models/Settlement.js';
+import { AbortSignal } from '@stamhoofd/queues';
 import { PaymentMethod, PaymentProvider, PaymentStatus } from '@stamhoofd/structures';
+import { STExpect } from '@stamhoofd/test-utils';
 import { v4 as uuidv4 } from 'uuid';
 import { vi } from 'vitest';
 
@@ -140,6 +142,57 @@ describe('Helper.SettlementSyncRunner', () => {
         expect(mollieRow.syncedAt).not.toBeNull();
     });
 
+    test('An aborted run walks nothing and does not report a failure', async () => {
+        const organization = await new OrganizationFactory({}).create();
+        const stripePayment = await createStripePayment(organization);
+
+        const payout = stripeMocker.createPayout({ amount: 10000, arrivalDate: new Date(2026, 0, 20) });
+        stripeMocker.createBalanceTransaction({
+            type: 'charge',
+            amount: 10000,
+            created: new Date(2026, 0, 15),
+            payout: payout.id,
+            source: stripeMocker.createChargeObject({ metadata: { payment: stripePayment.id } }),
+        });
+
+        const abort = new AbortSignal();
+        abort.abort();
+
+        // Throwing instead of returning a summary: a caller may not read an interrupted run as a
+        // completed one
+        await expect(new SettlementSyncRunner().run({
+            start: new Date(2026, 0, 1),
+            end: new Date(2026, 0, 31),
+            providers: [PaymentProvider.Stripe, PaymentProvider.Mollie],
+            abort,
+        })).rejects.toThrow(STExpect.simpleError({ code: 'queue-aborted' }));
+
+        expect(await Settlement.select().where('externalId', payout.id).first(false)).toBeNull();
+    });
+
+    test('An aborted run walks nothing of a provider Stripe never reached', async () => {
+        const mollieOrganization = await new OrganizationFactory({}).create();
+        await mollieMocker.setupToken(mollieOrganization);
+        const { mockPayment } = await createMolliePayment(mollieOrganization);
+        const mollieSettlement = mollieMocker.createSettlement({
+            payments: [mockPayment],
+            value: '50.00',
+            settledAt: new Date(2026, 0, 20),
+        });
+
+        const abort = new AbortSignal();
+        abort.abort();
+
+        await expect(new SettlementSyncRunner().run({
+            start: new Date(2026, 0, 1),
+            end: new Date(2026, 0, 31),
+            providers: [PaymentProvider.Mollie],
+            abort,
+        })).rejects.toThrow(STExpect.simpleError({ code: 'queue-aborted' }));
+
+        expect(await Settlement.select().where('externalId', mollieSettlement.id).first(false)).toBeNull();
+    });
+
     test('The stripe retryUnsynced option flows through the run', async () => {
         const organization = await new OrganizationFactory({}).create();
         const settlement = await SettlementService.upsertSettlement({

package/src/helpers/SettlementSyncRunner.ts

@@ -1,3 +1,4 @@
+import { AbortSignal } from '@stamhoofd/queues';
 import { PaymentProvider } from '@stamhoofd/structures';
 
 import { MollieSettlementSyncRunner } from './MollieSettlementSyncRunner.js';
@@ -19,11 +20,17 @@ export class SettlementSyncRunner {
      */
     callback: ((summary: SettlementSyncSummary) => void) | null = null;
 
-    async run({ start = new Date(2025, 0, 1), end, providers, stripe }: {
+    async run({ start = new Date(2025, 0, 1), end, providers, stripe, abort = new AbortSignal() }: {
         start?: Date;
         end?: Date | null;
         providers?: PaymentProvider[] | null;
         stripe?: StripeSyncOptions;
+
+        /**
+         * Stops the run at the next safe point, and throws what it was aborted with: a caller that
+         * treats a completed run as "done for today" may not mistake an interrupted one for it.
+         */
+        abort?: AbortSignal;
     } = {}): Promise<SettlementSyncSummary> {
         const summary: SettlementSyncSummary = { feeMonths: 0, failedFeeMonths: 0, synced: 0, skipped: 0, failed: 0 };
         const rangeEnd = end ?? new Date();
@@ -41,8 +48,12 @@ export class SettlementSyncRunner {
             if (includeStripe && STAMHOOFD.STRIPE_SECRET_KEY) {
                 const runner = new StripeSettlementSyncRunner({ secretKey: STAMHOOFD.STRIPE_SECRET_KEY, ...stripe });
                 try {
-                    await runner.run({ start, end: rangeEnd, summary, onProgress });
+                    await runner.run({ start, end: rangeEnd, summary, onProgress, abort });
                 } catch (e) {
+                    // An interrupted provider stops the whole run: it didn't fail, and the
+                    // providers after it would only be interrupted at their first step too
+                    abort.throwIfAborted();
+
                     console.error('Stripe settlement sync failed', e);
                     summary.failed += 1;
                 }
@@ -51,13 +62,19 @@ export class SettlementSyncRunner {
             if (includeMollie) {
                 const runner = new MollieSettlementSyncRunner();
                 try {
-                    await runner.run({ start, end: rangeEnd, summary, onProgress });
+                    await runner.run({ start, end: rangeEnd, summary, onProgress, abort });
                 } catch (e) {
+                    abort.throwIfAborted();
+
                     console.error('Mollie settlement sync failed', e);
                     summary.failed += 1;
                 }
             }
 
+            // A provider that ignores the signal (or a run without providers) may not hand back a
+            // summary that reads as a completed run
+            abort.throwIfAborted();
+
             return summary;
         });
     }

package/src/helpers/StripeSettlementSync.test.ts

@@ -2,16 +2,25 @@ import { EmailMocker } from '@stamhoofd/email';
 import type { Organization, StripeAccount } from '@stamhoofd/models';
 import { OrganizationFactory, Payment, Platform } from '@stamhoofd/models';
 import { ApplicationFee } from '@stamhoofd/models/models/ApplicationFee.js';
+import { BalanceItem } from '@stamhoofd/models/models/BalanceItem.js';
+import { BalanceItemPayment } from '@stamhoofd/models/models/BalanceItemPayment.js';
 import { PaymentSettlement } from '@stamhoofd/models/models/PaymentSettlement.js';
+import type { Settlement as SettlementModel } from '@stamhoofd/models/models/Settlement.js';
 import { Settlement } from '@stamhoofd/models/models/Settlement.js';
 import { SettlementCharge } from '@stamhoofd/models/models/SettlementCharge.js';
-import { PaymentMethod, PaymentProvider, PaymentStatus, PaymentType } from '@stamhoofd/structures';
+import { AbortSignal } from '@stamhoofd/queues';
+import { BalanceItemStatus, BalanceItemType, PaymentMethod, PaymentProvider, PaymentStatus, PaymentType } from '@stamhoofd/structures';
 import { ApplicationFeeType } from '@stamhoofd/structures/settlements/ApplicationFeeType.js';
 import { SettlementChargeType } from '@stamhoofd/structures/settlements/SettlementChargeType.js';
 import { SettlementStatus } from '@stamhoofd/structures/settlements/SettlementStatus.js';
+import { STExpect } from '@stamhoofd/test-utils';
+import { v4 as uuidv4 } from 'uuid';
+import { vi } from 'vitest';
 
 import { StripeMocker } from '../../tests/helpers/StripeMocker.js';
 import type { StripeObject } from '../../tests/helpers/StripeMocker.js';
+import { ApplicationFeeService } from '../services/ApplicationFeeService.js';
+import { SettlementService } from '../services/SettlementService.js';
 import { StripeSettlementSync } from './StripeSettlementSync.js';
 import { StripeSettlementSyncRunner } from './StripeSettlementSyncRunner.js';
 import { WebmasterReport } from './WebmasterReport.js';
@@ -45,6 +54,7 @@ describe('StripeSettlementSync', () => {
 
     beforeEach(() => {
         stripeMocker.clear();
+        StripeSettlementSync.resetWarnings();
     });
 
     const createSync = () => new StripeSettlementSync({ secretKey: STAMHOOFD.STRIPE_SECRET_KEY! });
@@ -69,6 +79,54 @@ describe('StripeSettlementSync', () => {
         return await Settlement.select().where('externalId', payout.id).first(true);
     };
 
+    /**
+     * A fee we already invoiced to the organization, like the ApplicationFeeInvoicer stores it: the
+     * membership organization bills it, the organization pays it. Every payout that contains such a
+     * fee needs a derived line on its fee payment.
+     */
+    const createInvoicedFee = async (externalId: string, amount: number, { settlement = null as SettlementModel | null } = {}) => {
+        const payment = new Payment();
+        payment.organizationId = membershipOrganization.id;
+        payment.payingOrganizationId = organization.id;
+        payment.stripeAccountId = stripeAccount.id;
+        payment.method = PaymentMethod.AccountDeductions;
+        payment.provider = PaymentProvider.Stripe;
+        payment.status = PaymentStatus.Succeeded;
+        payment.price = amount;
+        payment.paidAt = created;
+        await payment.save();
+
+        const balanceItem = new BalanceItem();
+        balanceItem.type = BalanceItemType.ServiceFee;
+        balanceItem.organizationId = membershipOrganization.id;
+        balanceItem.payingOrganizationId = organization.id;
+        balanceItem.unitPrice = amount;
+        balanceItem.quantity = 1;
+        balanceItem.status = BalanceItemStatus.Hidden;
+        await balanceItem.save();
+
+        const balanceItemPayment = new BalanceItemPayment();
+        balanceItemPayment.balanceItemId = balanceItem.id;
+        balanceItemPayment.paymentId = payment.id;
+        balanceItemPayment.organizationId = payment.organizationId;
+        balanceItemPayment.price = amount;
+        await balanceItemPayment.save();
+
+        const fee = new ApplicationFee();
+        fee.externalId = externalId;
+        fee.type = ApplicationFeeType.Service;
+        fee.amount = amount;
+        fee.organizationId = membershipOrganization.id;
+        fee.payingOrganizationId = organization.id;
+        fee.payingStripeAccountId = stripeAccount.id;
+        fee.balanceItemId = balanceItem.id;
+        fee.settlementId = settlement?.id ?? null;
+        fee.occurredAt = created;
+        await fee.save();
+
+        return { payment, fee };
+    };
+
     test('a full destination-charge payout reconciles to zero', async () => {
         const payment = await createPayment({ price: 100_00_00 });
         const payout = stripeMocker.createPayout({ amount: 225, arrivalDate });
@@ -357,6 +415,85 @@ describe('StripeSettlementSync', () => {
         expect(emails[0].html).toContain(second.id);
     });
 
+    test('a walk that fails still updates the fee payments of what it stored', async () => {
+        const payerPayment = await createPayment();
+        const stripeFee = stripeMocker.createApplicationFee({
+            amount: 250,
+            account: stripeAccount.accountId,
+            originatingTransaction: stripeMocker.createChargeObject({ metadata: { payment: payerPayment.id, serviceFee: '250' } }),
+        });
+        const { payment: feePayment } = await createInvoicedFee(stripeFee.id, 2_50_00);
+
+        const payout = stripeMocker.createPayout({ amount: 250, arrivalDate });
+        stripeMocker.createBalanceTransaction({ type: 'application_fee', amount: 250, created, payout: payout.id, source: stripeFee });
+
+        // Fails the walk after the fee was linked to the payout
+        stripeMocker.createBalanceTransaction({ type: 'issuing_authorization_hold', amount: 100, created, payout: payout.id, source: null });
+
+        expect(await createSync().syncPayouts({ start })).toEqual({ synced: 0, skipped: 0, failed: 1 });
+
+        // The walk linked the fee to this payout before it failed, so the fee payment gets its
+        // derived line: a fee may never sit in a payout that has no line for it
+        const settlement = await getSettlement(payout);
+        expect(settlement.syncedAt).toBeNull();
+
+        const derived = await PaymentSettlement.select().where('paymentId', feePayment.id).fetch();
+        expect(derived).toHaveLength(1);
+        expect(derived[0]).toMatchObject({
+            settlementId: settlement.id,
+            externalId: null,
+            amount: 2_50_00,
+        });
+    });
+
+    test('a fee walk updates the fee payments of the fees it stored before one failed', async () => {
+        const payerPayment = await createPayment();
+        const stripeFee = stripeMocker.createApplicationFee({
+            amount: 250,
+            account: stripeAccount.accountId,
+            // Both a service and a transfer part, so the fee is stored as two rows
+            originatingTransaction: stripeMocker.createChargeObject({ metadata: { payment: payerPayment.id, serviceFee: '30' } }),
+        });
+
+        // Already paid out and invoiced before this walk: the payout it sits in explains it through
+        // the derived line of its fee payment
+        const settlement = await SettlementService.upsertSettlement({
+            provider: PaymentProvider.Stripe,
+            externalId: 'po_' + uuidv4(),
+            organizationId: membershipOrganization.id,
+            amount: 30_00,
+            settledAt: arrivalDate,
+        });
+        const { payment: feePayment } = await createInvoicedFee(stripeFee.id, 30_00, { settlement });
+
+        stripeMocker.createBalanceTransaction({ type: 'application_fee', amount: 250, created, source: stripeFee });
+
+        // The service fee is stored, the transfer fee of the same transaction fails after it
+        const upsertFee = ApplicationFeeService.upsertFee.bind(ApplicationFeeService);
+        const spy = vi.spyOn(ApplicationFeeService, 'upsertFee').mockImplementation(async (data) => {
+            if (data.type === ApplicationFeeType.Transfer) {
+                throw new Error('Storing the transfer fee failed');
+            }
+            return await upsertFee(data);
+        });
+
+        try {
+            await expect(createSync().syncFees({ start, end: arrivalDate })).rejects.toThrow(
+                STExpect.simpleError({ code: 'stripe_fee_sync_failed' }),
+            );
+        } finally {
+            spy.mockRestore();
+        }
+
+        const derived = await PaymentSettlement.select().where('paymentId', feePayment.id).fetch();
+        expect(derived).toHaveLength(1);
+        expect(derived[0]).toMatchObject({
+            settlementId: settlement.id,
+            externalId: null,
+            amount: 30_00,
+        });
+    });
+
     test('a payout that failed after being paid keeps its status current', async () => {
         const payment = await createPayment();
         const payout = stripeMocker.createPayout({ amount: 10000, arrivalDate, stripeAccount: stripeAccount.accountId });
@@ -610,6 +747,173 @@ describe('StripeSettlementSync', () => {
         expect(after.pendingFees).toBe(0);
     });
 
+    describe('Payers we can no longer reach', () => {
+        /**
+         * A platform payout that only receives one application fee, plus the payout transaction.
+         * The metadata defaults to a payment that no longer exists.
+         */
+        const createFeePayout = (account: string, metadata: Record<string, string> = {}) => {
+            const payout = stripeMocker.createPayout({ amount: 250, arrivalDate });
+            const fee = stripeMocker.createApplicationFee({
+                amount: 250,
+                account,
+                originatingTransaction: stripeMocker.createChargeObject({ metadata: { payment: uuidv4(), serviceFee: '30', ...metadata } }),
+            });
+            stripeMocker.createBalanceTransaction({ type: 'application_fee', amount: 250, created, payout: payout.id, source: fee });
+            stripeMocker.createBalanceTransaction({ type: 'payout', amount: -250, created, payout: payout.id, source: null });
+            return { payout, fee };
+        };
+
+        test('a fee of an organization that no longer exists is stored as income without a payer', async () => {
+            const { payout, fee } = createFeePayout(stripeMocker.createId('acct'), { organization: uuidv4() });
+
+            expect(await createSync().syncPayouts({ start })).toEqual({ synced: 1, skipped: 0, failed: 0 });
+
+            const settlement = await getSettlement(payout);
+            const fees = await ApplicationFee.select().where('externalId', fee.id).fetch();
+            expect(fees).toHaveLength(2);
+            for (const row of fees) {
+                expect(row.organizationId).toBe(membershipOrganization.id);
+                expect(row.settlementId).toBe(settlement.id);
+                expect(row.payingOrganizationId).toBeNull();
+                expect(row.payingStripeAccountId).toBeNull();
+                expect(row.payingPaymentId).toBeNull();
+                expect(row.settlementChargeId).toBeNull();
+            }
+
+            // There is no payout of theirs left to deduct it from, but ours still adds up
+            expect(await SettlementCharge.select().where('applicationFeeId', fee.id).count()).toBe(0);
+            expect(settlement.unexplainedAmount).toBe(0);
+            expect(settlement.pendingFees).toBe(0);
+            expect(settlement.uncollectibleFees).toBe(2_50_00);
+        });
+
+        test('a fee of a Stripe account we no longer have keeps the payer of its payment', async () => {
+            const payment = await createPayment();
+            const { payout, fee } = createFeePayout(stripeMocker.createId('acct'), { payment: payment.id });
+
+            expect(await createSync().syncPayouts({ start })).toEqual({ synced: 1, skipped: 0, failed: 0 });
+
+            // The cost is still attributed to the organization, so its own export shows it
+            const charges = await SettlementCharge.select().where('applicationFeeId', fee.id).fetch();
+            expect(charges).toHaveLength(2);
+            for (const charge of charges) {
+                expect(charge.organizationId).toBe(organization.id);
+                expect(charge.stripeAccountId).toBeNull();
+                expect(charge.paymentId).toBe(payment.id);
+            }
+
+            const fees = await ApplicationFee.select().where('externalId', fee.id).fetch();
+            for (const row of fees) {
+                expect(row.payingOrganizationId).toBe(organization.id);
+                expect(row.payingStripeAccountId).toBeNull();
+                expect(row.payingPaymentId).toBe(payment.id);
+                expect(row.settlementChargeId).not.toBeNull();
+            }
+
+            // Without the account it was deducted from, the invoicer can't bill it per account
+            const settlement = await getSettlement(payout);
+            expect(settlement.pendingFees).toBe(0);
+            expect(settlement.uncollectibleFees).toBe(2_50_00);
+            expect(settlement.unexplainedAmount).toBe(0);
+        });
+
+        test('a fee whose payment is gone falls back to the organization in our charge metadata', async () => {
+            const { payout, fee } = createFeePayout(stripeMocker.createId('acct'), { organization: organization.id });
+
+            expect(await createSync().syncPayouts({ start })).toEqual({ synced: 1, skipped: 0, failed: 0 });
+
+            const charges = await SettlementCharge.select().where('applicationFeeId', fee.id).fetch();
+            expect(charges).toHaveLength(2);
+            for (const charge of charges) {
+                expect(charge.organizationId).toBe(organization.id);
+                expect(charge.paymentId).toBeNull();
+            }
+
+            const fees = await ApplicationFee.select().where('externalId', fee.id).fetch();
+            for (const row of fees) {
+                expect(row.payingOrganizationId).toBe(organization.id);
+                expect(row.payingPaymentId).toBeNull();
+            }
+
+            expect((await getSettlement(payout)).uncollectibleFees).toBe(2_50_00);
+        });
+
+        test('every unattributable account is reported once, not once per fee', async () => {
+            const unknownAccount = stripeMocker.createId('acct');
+            createFeePayout(unknownAccount, { organization: uuidv4() });
+            createFeePayout(unknownAccount, { organization: uuidv4() });
+
+            await WebmasterReport.group('Onaanrekenbare applicatiekosten', async () => {
+                expect(await createSync().syncPayouts({ start })).toEqual({ synced: 2, skipped: 0, failed: 0 });
+            });
+
+            const emails = (await EmailMocker.transactional.getSucceededEmails()).filter(e => e.subject.startsWith('Onaanrekenbare applicatiekosten'));
+            expect(emails).toHaveLength(1);
+            expect(emails[0].html).toContain(unknownAccount);
+            expect(emails[0].subject).toContain('1 probleem');
+        });
+
+        test('a deleted Stripe account keeps its organization, its account and its payment', async () => {
+            const deletedOrganization = await new OrganizationFactory({}).create();
+            const deletedAccount = await stripeMocker.createStripeAccount(deletedOrganization.id);
+            deletedAccount.status = 'deleted';
+            await deletedAccount.save();
+
+            // Deleting a Stripe account is a soft delete: the organization and its payments stay
+            const payment = new Payment();
+            payment.organizationId = deletedOrganization.id;
+            payment.stripeAccountId = deletedAccount.id;
+            payment.method = PaymentMethod.Bancontact;
+            payment.provider = PaymentProvider.Stripe;
+            payment.status = PaymentStatus.Succeeded;
+            payment.type = PaymentType.Payment;
+            payment.price = 100_00_00;
+            payment.paidAt = created;
+            await payment.save();
+
+            const { payout, fee } = createFeePayout(deletedAccount.accountId, { payment: payment.id });
+
+            expect(await createSync().syncPayouts({ start })).toEqual({ synced: 1, skipped: 0, failed: 0 });
+
+            const charges = await SettlementCharge.select().where('applicationFeeId', fee.id).fetch();
+            expect(charges).toHaveLength(2);
+            for (const charge of charges) {
+                expect(charge.organizationId).toBe(deletedOrganization.id);
+                expect(charge.stripeAccountId).toBe(deletedAccount.id);
+                expect(charge.paymentId).toBe(payment.id);
+            }
+
+            const fees = await ApplicationFee.select().where('externalId', fee.id).fetch();
+            for (const row of fees) {
+                expect(row.payingOrganizationId).toBe(deletedOrganization.id);
+                expect(row.payingStripeAccountId).toBe(deletedAccount.id);
+                expect(row.payingPaymentId).toBe(payment.id);
+            }
+
+            // Nothing was lost, so it is billed like any other month
+            const settlement = await getSettlement(payout);
+            expect(settlement.pendingFees).toBe(2_50_00);
+            expect(settlement.uncollectibleFees).toBe(0);
+        });
+
+        test('an account still in our database keeps failing the payout on an unresolvable payment', async () => {
+            const deletedAccount = await stripeMocker.createStripeAccount(organization.id);
+            deletedAccount.status = 'deleted';
+            await deletedAccount.save();
+
+            // A deleted account is no reason to stop checking: an organization may not attach
+            // another organization's payment to its fees by deleting its Stripe account first
+            for (const account of [stripeAccount, deletedAccount]) {
+                const { payout } = createFeePayout(account.accountId);
+
+                expect(await createSync().syncPayouts({ start })).toEqual({ synced: 0, skipped: 0, failed: 1 });
+                expect((await getSettlement(payout)).syncedAt).toBeNull();
+                stripeMocker.clear();
+            }
+        });
+    });
+
     describe('Connected accounts', () => {
         test('an organization payout writes the mirrored deduction rows, summing to zero against the Received rows', async () => {
             const payment = await createPayment();
@@ -825,4 +1129,74 @@ describe('StripeSettlementSync', () => {
             expect(settlement.syncedAt).toBeNull();
         });
     });
+
+    describe('Aborting', () => {
+        /**
+         * Aborts the walk while it stores its first row, so the payout is interrupted halfway.
+         */
+        const abortDuringWalk = () => {
+            const abort = new AbortSignal();
+            const upsertCharge = SettlementService.upsertCharge.bind(SettlementService);
+
+            const spy = vi.spyOn(SettlementService, 'upsertCharge').mockImplementation(async (data) => {
+                abort.abort();
+                return await upsertCharge(data);
+            });
+
+            return { abort, restore: () => spy.mockRestore() };
+        };
+
+        test('an interrupted walk gives up its synced state without counting a failure', async () => {
+            const payout = stripeMocker.createPayout({ amount: 2000, arrivalDate });
+            for (let i = 0; i < 2; i++) {
+                stripeMocker.createBalanceTransaction({ type: 'stripe_fee', amount: 1000, created, payout: payout.id, source: null });
+            }
+
+            expect(await createSync().syncPayouts({ start })).toEqual({ synced: 1, skipped: 0, failed: 0 });
+            expect((await getSettlement(payout)).syncedAt).not.toBeNull();
+
+            const { abort, restore } = abortDuringWalk();
+            try {
+                await WebmasterReport.group('Onderbroken synchronisatie', async () => {
+                    await expect(createSync().syncPayouts({ start, force: true, abort })).rejects.toThrow(
+                        STExpect.simpleError({ code: 'queue-aborted' }),
+                    );
+                });
+            } finally {
+                restore();
+            }
+
+            // Only part of the payout was walked, so it may not keep claiming it is synced. A
+            // restart is not a failure of this payout: it doesn't count towards the retry cap
+            const settlement = await getSettlement(payout);
+            expect(settlement.syncedAt).toBeNull();
+            expect(settlement.syncFailureCount).toBe(0);
+
+            const emails = (await EmailMocker.transactional.getSucceededEmails()).filter(e => e.subject.startsWith('Onderbroken synchronisatie'));
+            expect(emails).toHaveLength(0);
+        });
+
+        test('the payouts after an interrupted one are left untouched', async () => {
+            const interrupted = stripeMocker.createPayout({ amount: 2000, arrivalDate });
+            for (let i = 0; i < 2; i++) {
+                stripeMocker.createBalanceTransaction({ type: 'stripe_fee', amount: 1000, created, payout: interrupted.id, source: null });
+            }
+
+            const untouched = stripeMocker.createPayout({ amount: 1000, arrivalDate });
+            stripeMocker.createBalanceTransaction({ type: 'stripe_fee', amount: 1000, created, payout: untouched.id, source: null });
+
+            const { abort, restore } = abortDuringWalk();
+            try {
+                await expect(createSync().syncPayouts({ start, abort })).rejects.toThrow(
+                    STExpect.simpleError({ code: 'queue-aborted' }),
+                );
+            } finally {
+                restore();
+            }
+
+            // The loop stopped at the payout it was walking: the other one was never started
+            expect((await getSettlement(interrupted)).syncedAt).toBeNull();
+            expect(await Settlement.select().where('externalId', untouched.id).count()).toBe(0);
+        });
+    });
 });