@stamhoofd/backend 2.141.0 → 2.142.0

package/src/helpers/ApplicationFeeInvoicer.ts

@@ -84,9 +84,7 @@ export class ApplicationFeeInvoicer {
         const snapshot = truncateToSecond(new Date());
 
         const currentPeriodStart = SettlementService.getPeriodStart(new Date());
-        const oldest = await ApplicationFee.select()
-            .where('organizationId', sellingOrganization.id)
-            .where('balanceItemId', null)
+        const oldest = await this.#selectBillableFees(sellingOrganization)
             .where('occurredAt', '<', currentPeriodStart)
             .where('createdAt', '<', snapshot)
             .orderBy('occurredAt', 'ASC')
@@ -149,15 +147,16 @@ export class ApplicationFeeInvoicer {
         const reference = ApplicationFeeInvoicer.reference(periodStart);
 
         await QueueHandler.schedule(reference, async () => {
-            const totalsPerAccount = new Map<string | null, AccountTotals>();
+            const totalsPerAccount = new Map<string, AccountTotals>();
 
+            // Both ids are non-null: #selectUninvoicedFees only returns fees that can be billed
             for await (const fee of this.#selectUninvoicedFees(sellingOrganization, periodStart, nextPeriodStart, snapshot).all()) {
-                const totals = totalsPerAccount.get(fee.payingStripeAccountId) ?? {
-                    payingOrganizationId: fee.payingOrganizationId,
+                const totals = totalsPerAccount.get(fee.payingStripeAccountId!) ?? {
+                    payingOrganizationId: fee.payingOrganizationId!,
                     amountPerType: new Map<ApplicationFeeType, number>(),
                 };
                 totals.amountPerType.set(fee.type, (totals.amountPerType.get(fee.type) ?? 0) + fee.amount);
-                totalsPerAccount.set(fee.payingStripeAccountId, totals);
+                totalsPerAccount.set(fee.payingStripeAccountId!, totals);
             }
 
             for (const [payingStripeAccountId, totals] of totalsPerAccount) {
@@ -171,19 +170,32 @@ export class ApplicationFeeInvoicer {
         });
     }
 
+    /**
+     * A fee this invoicer cannot bill is left out everywhere, or every run would walk its month at
+     * Stripe and report it again: without a paying organization there is nobody left to bill, and
+     * without its Stripe account a month cannot be checked against what the legacy invoicer billed
+     * per account — billing it anyway risks charging it twice. Both are reported by the sync that
+     * stored them (StripeSettlementSync.reportUnattributedFee).
+     */
     #selectUninvoicedFees(sellingOrganization: Organization, periodStart: Date, nextPeriodStart: Date, snapshot: Date) {
-        return ApplicationFee.select()
-            .where('organizationId', sellingOrganization.id)
-            .where('balanceItemId', null)
+        return this.#selectBillableFees(sellingOrganization)
             .where('occurredAt', '>=', periodStart)
             .where('occurredAt', '<', nextPeriodStart)
             .where('createdAt', '<', snapshot)
             .limit(FEE_BATCH_SIZE);
     }
 
+    #selectBillableFees(sellingOrganization: Organization) {
+        return ApplicationFee.select()
+            .where('organizationId', sellingOrganization.id)
+            .where('balanceItemId', null)
+            .where('payingOrganizationId', '!=', null)
+            .where('payingStripeAccountId', '!=', null);
+    }
+
     async #invoiceGroup({ sellingOrganization, payingStripeAccountId, totals, periodStart, nextPeriodStart, snapshot }: {
         sellingOrganization: Organization;
-        payingStripeAccountId: string | null;
+        payingStripeAccountId: string;
         totals: AccountTotals;
         periodStart: Date;
         nextPeriodStart: Date;
@@ -194,13 +206,6 @@ export class ApplicationFeeInvoicer {
             return;
         }
 
-        if (!payingStripeAccountId) {
-            throw new SimpleError({
-                code: 'missing_stripe_account',
-                message: 'Uninvoiced application fees without a Stripe account',
-            });
-        }
-
         const stripeAccount = await StripeAccount.getByID(payingStripeAccountId);
         if (!stripeAccount) {
             throw new SimpleError({

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/StripeSettlementSync.test.ts

@@ -9,6 +9,7 @@ import { PaymentMethod, PaymentProvider, PaymentStatus, PaymentType } from '@sta
 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 { v4 as uuidv4 } from 'uuid';
 
 import { StripeMocker } from '../../tests/helpers/StripeMocker.js';
 import type { StripeObject } from '../../tests/helpers/StripeMocker.js';
@@ -45,6 +46,7 @@ describe('StripeSettlementSync', () => {
 
     beforeEach(() => {
         stripeMocker.clear();
+        StripeSettlementSync.resetWarnings();
     });
 
     const createSync = () => new StripeSettlementSync({ secretKey: STAMHOOFD.STRIPE_SECRET_KEY! });
@@ -610,6 +612,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();

package/src/helpers/StripeSettlementSync.ts

@@ -1,5 +1,5 @@
 import { SimpleError } from '@simonbackx/simple-errors';
-import { Payment, StripeAccount } from '@stamhoofd/models';
+import { Organization, Payment, StripeAccount } from '@stamhoofd/models';
 import { ApplicationFee } from '@stamhoofd/models/models/ApplicationFee.js';
 import { PaymentSettlement } from '@stamhoofd/models/models/PaymentSettlement.js';
 import type { Settlement } from '@stamhoofd/models/models/Settlement.js';
@@ -17,6 +17,27 @@ import { passthroughFetch } from './passthroughFetch.js';
 import { getPaymentIdForStripeCharge } from './getPaymentIdForStripeCharge.js';
 import { WebmasterReport } from './WebmasterReport.js';
 
+/**
+ * Who paid an application fee: normally the organization of the Stripe account it was deducted
+ * from, and otherwise the organization our own charge metadata names.
+ */
+type ApplicationFeePayer = {
+    organizationId: string;
+
+    /**
+     * NULL when we no longer have the stripe_accounts row the fee was deducted from.
+     */
+    stripeAccountId: string | null;
+
+    /**
+     * Whether our records of this payer are still complete. Only false when its stripe_accounts
+     * row is gone, which means its organization was deleted: what can't be resolved anymore is
+     * then the consequence of that deletion, not a problem to repair. A deleted account keeps its
+     * row, and its organization keeps its payments, so those stay strictly checked.
+     */
+    intact: boolean;
+};
+
 /**
  * Walks paid payouts and stores every balance transaction in them: payments become
  * payment_settlements rows, everything else becomes settlement_charges rows. One walker for both
@@ -37,6 +58,38 @@ export class StripeSettlementSync {
      */
     private fetchedCharges = new Map<string, Stripe.Charge>();
 
+    /**
+     * Stripe accounts already reported as unattributable, so a month of their fees is one problem
+     * instead of thousands.
+     */
+    static #reportedUnattributedAccounts = new Set<string>();
+
+    /**
+     * For tests only.
+     */
+    static resetWarnings() {
+        this.#reportedUnattributedAccounts.clear();
+    }
+
+    /**
+     * A fee we can't fully attribute is stored anyway (it is our income), so it would otherwise
+     * only exist as a number nobody looks at: the invoicer skips it, and no payout of the payer
+     * links it. Reported once per account, so someone decides whether to repair or write it off.
+     */
+    static reportUnattributedFee(payingAccountId: string, payer: ApplicationFeePayer | null) {
+        if (this.#reportedUnattributedAccounts.has(payingAccountId)) {
+            return;
+        }
+        this.#reportedUnattributedAccounts.add(payingAccountId);
+
+        WebmasterReport.report(
+            'Applicatiekosten van Stripe account ' + payingAccountId + ' worden niet aangerekend',
+            payer
+                ? 'Dat account staat niet meer in onze database. De kosten zijn wel opgeslagen op vereniging ' + payer.organizationId + ', maar worden niet automatisch gefactureerd.'
+                : 'Dat account en de vereniging erachter staan niet meer in onze database. De kosten zijn opgeslagen als niet-aanrekenbare inkomsten.',
+        );
+    }
+
     constructor({ secretKey, stripeAccount }: { secretKey: string; stripeAccount?: StripeAccount | null }) {
         this.stripeAccount = stripeAccount ?? null;
 
@@ -155,25 +208,12 @@ export class StripeSettlementSync {
     }
 
     /**
-     * Stores one application_fee balance transaction: per non-zero part the payer's negative
-     * deduction charge (its settlement link belongs to the payer's own payout walk) and the
-     * application fee row. The platform payout walk passes `settlementId` to link the fee rows to
-     * the payout that contains them. Throws instead of writing a guessed row: missing serviceFee
-     * metadata, an unknown Stripe account or an unresolvable payment all mean someone has to look
-     * at it first.
+     * Stores the SettlementCharge for the connected account (costs) and ApplicationFee for the platform account (revenue), related to an application fee in Stripe.
      */
     async #handleApplicationFee(transaction: Stripe.BalanceTransaction, options: { settlementId?: string } = {}): Promise<{ fees: ApplicationFee[]; charges: SettlementCharge[] }> {
         const fee = transaction.source as Stripe.ApplicationFee;
         const payingAccountId = typeof fee.account === 'string' ? fee.account : fee.account.id;
 
-        const payingStripeAccount = await StripeAccount.select().where('accountId', payingAccountId).first(false);
-        if (!payingStripeAccount) {
-            throw new SimpleError({
-                code: 'stripe_account_not_found',
-                message: 'No Stripe account found for ' + payingAccountId,
-            });
-        }
-
         const originatingTransaction = fee.originating_transaction;
         if (!originatingTransaction || typeof originatingTransaction === 'string') {
             throw new SimpleError({
@@ -181,28 +221,18 @@ export class StripeSettlementSync {
                 message: 'Application fee ' + fee.id + ' has no expanded originating transaction',
             });
         }
-
+        const originatingCharge = originatingTransaction as Stripe.Charge;
         const details = ApplicationFeeDetails.fromStripe(transaction);
-
-        const paymentId = await getPaymentIdForStripeCharge(originatingTransaction as Stripe.Charge, {
+        const resolvedPaymentId = await getPaymentIdForStripeCharge(originatingCharge, {
             stripePlatform: this.stripePlatform,
         });
+        const resolvedPayment = (resolvedPaymentId ? await Payment.getByID(resolvedPaymentId) : null) ?? null;
 
-        if (!paymentId) {
-            throw new SimpleError({
-                code: 'payment_not_found',
-                message: 'No payment found for application fee ' + fee.id,
-            });
-        }
+        const payer = await this.#resolveApplicationFeePayer(payingAccountId, originatingCharge, resolvedPayment);
+        const paymentId = this.#getApplicationFeePaymentId(fee, payer, { paymentId: resolvedPaymentId, payment: resolvedPayment });
 
-        // Charge metadata is writable by the connected account's owner: the fee is deducted from
-        // this account, so it can only be about a payment of its own organization
-        const payment = await Payment.getByID(paymentId);
-        if (!payment || payment.organizationId !== payingStripeAccount.organizationId) {
-            throw new SimpleError({
-                code: 'payment_scope_mismatch',
-                message: 'Payment ' + paymentId + ' of application fee ' + fee.id + ' does not belong to organization ' + payingStripeAccount.organizationId,
-            });
+        if (!payer?.stripeAccountId) {
+            StripeSettlementSync.reportUnattributedFee(payingAccountId, payer);
         }
 
         const occurredAt = new Date(transaction.created * 1000);
@@ -222,39 +252,115 @@ export class StripeSettlementSync {
                 continue;
             }
 
-            const charge = await SettlementService.upsertCharge({
-                type: chargeType,
-                externalId: fee.id + ':' + chargeType,
-                amount: -amount,
-                applicationFeeId: fee.id,
-                paymentId,
-
-                // The charge sits in the paying organization's payout
-                organizationId: payingStripeAccount.organizationId,
-                stripeAccountId: payingStripeAccount.id,
-                occurredAt,
-
-                // settlementId (settlement of the paying organization where the costs are deducted): still unknown, will be filled when looping the payouts of the paying organization
-            });
-            charges.push(charge);
+            const charge = payer
+                ? await SettlementService.upsertCharge({
+                        type: chargeType,
+                        externalId: fee.id + ':' + chargeType,
+                        amount: -amount,
+                        applicationFeeId: fee.id,
+
+                        // Unresolvable stays undefined: a re-sync may not clear earlier stored links
+                        paymentId: paymentId ?? undefined,
+                        organizationId: payer.organizationId ?? undefined,
+                        stripeAccountId: payer.stripeAccountId ?? undefined,
+                        occurredAt,
+
+                        // settlementId (settlement of the paying organization where the costs are deducted): still unknown, will be filled when looping the payouts of the paying organization
+                    })
+                : null;
+
+            if (charge) {
+                charges.push(charge);
+            }
 
             fees.push(await ApplicationFeeService.upsertFee({
                 externalId: fee.id,
                 type: feeType,
                 amount,
                 organizationId: receivingOrganizationId,
-                payingOrganizationId: payingStripeAccount.organizationId,
-                payingStripeAccountId: payingStripeAccount.id,
-                payingPaymentId: paymentId,
-                settlementChargeId: charge.id,
+
+                // Unresolvable stays undefined: a re-sync may not clear earlier stored links
+                payingOrganizationId: payer?.organizationId ?? undefined,
+                payingStripeAccountId: payer?.stripeAccountId ?? undefined,
+                payingPaymentId: paymentId ?? undefined,
+                settlementChargeId: charge?.id ?? undefined,
+                settlementId: options.settlementId,
                 occurredAt,
-                ...(options.settlementId !== undefined ? { settlementId: options.settlementId } : {}),
             }));
         }
 
         return { fees, charges };
     }
 
+    /**
+     * The organization an application fee was deducted from. Its Stripe account is the first
+     * source. A deleted organization takes its stripe_accounts row with it, and accounts deleted
+     * before we started keeping deleted ones are gone too; what is left of the payment then still
+     * names the organization: our own payment row first, and otherwise the metadata we wrote on the
+     * charge. Only a destination charge has an originating transaction, and that charge sits on our
+     * platform account, so the connected account could not have changed either.
+     *
+     * NULL when even that organization no longer exists: the fee is then income without a payer.
+     */
+    async #resolveApplicationFeePayer(payingAccountId: string, originatingCharge: Stripe.Charge, payment: Payment | null): Promise<ApplicationFeePayer | null> {
+        const stripeAccount = await StripeAccount.select().where('accountId', payingAccountId).first(false);
+        if (stripeAccount) {
+            return {
+                organizationId: stripeAccount.organizationId,
+                stripeAccountId: stripeAccount.id,
+                intact: true,
+            };
+        }
+
+        if (payment?.organizationId) {
+            return { organizationId: payment.organizationId, stripeAccountId: null, intact: false };
+        }
+
+        const organizationId = originatingCharge.metadata?.organization;
+        if (!organizationId || !await Organization.getByID(organizationId)) {
+            return null;
+        }
+
+        return { organizationId, stripeAccountId: null, intact: false };
+    }
+
+    /**
+     * The payer's payment an application fee was charged on. Charge metadata is writable by the
+     * connected account's owner: the fee is deducted from this account, so it can only be about a
+     * payment of its own organization.
+     *
+     * A payer whose records are no longer intact keeps whatever still resolves: its payments may
+     * have been deleted with its account, so a missing one is expected instead of something to
+     * repair.
+     */
+    #getApplicationFeePaymentId(fee: Stripe.ApplicationFee, payer: ApplicationFeePayer | null, { paymentId, payment }: { paymentId: string | null; payment: Payment | null }): string | null {
+        if (!payer) {
+            return null;
+        }
+
+        if (!paymentId) {
+            if (!payer.intact) {
+                return null;
+            }
+            throw new SimpleError({
+                code: 'payment_not_found',
+                message: 'No payment found for application fee ' + fee.id,
+            });
+        }
+
+        if (!payment || payment.organizationId !== payer.organizationId) {
+            if (!payer.intact) {
+                return null;
+            }
+            throw new SimpleError({
+                code: 'payment_scope_mismatch',
+                message: 'Payment ' + paymentId + ' of application fee ' + fee.id + ' does not belong to organization ' + payer.organizationId,
+            });
+        }
+
+        return paymentId;
+    }
+
     /**
      * The organization that owns the walked account: the connected account's organization, or the
      * platform membership organization for our own platform account (resolved once per instance).

package/src/helpers/StripeSettlementSyncRunner.ts

@@ -103,6 +103,14 @@ export class StripeSettlementSyncRunner implements ProviderSettlementSyncRunner
                 totals.skipped += result.skipped;
                 totals.failed += result.failed;
             } catch (e) {
+                if (e !== null && typeof e === 'object' && 'type' in e && e.type === 'StripePermissionError' && e.message.includes(account.accountId) && e.message.includes('does not have access to account')) {
+                    // Stripe account no longer in active use
+                    console.error(e, 'marking stripe account', account.id, account.accountId, 'as inaccessible because we do not seem to have access to it any longer');
+                    account.status = 'inaccessible';
+                    await account.save();
+                    totals.skipped += 1;
+                    continue;
+                }
                 console.error('Failed to sync payouts of Stripe account ' + account.accountId, e);
                 totals.failed += 1;