@stamhoofd/backend 2.141.0 → 2.143.0

package/src/endpoints/global/registration-invitations/PatchRegistrationInvitationsEndpoint.ts

@@ -35,11 +35,15 @@ export class PatchRegistrationInvitationsEndpoint extends Endpoint<Params, Query
     }
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
-        const organization = await Context.setOrganizationScope();
+        const organization = await Context.setOptionalOrganizationScope();
         await Context.authenticate();
 
         // Fast throw first (more in depth checking for patches later)
-        if (!await Context.auth.hasSomeAccess(organization.id)) {
+        if (organization) {
+            if (!await Context.auth.hasSomeAccess(organization.id)) {
+                throw Context.auth.error();
+            }
+        } else if (!Context.auth.hasSomePlatformAccess()) {
             throw Context.auth.error();
         }
 
@@ -48,11 +52,11 @@ export class PatchRegistrationInvitationsEndpoint extends Endpoint<Params, Query
 
         const puts = request.body.getPuts();
         for (const { put } of puts) {
-            await this.checkCanCreateRegistrationInvitation(put, organization.id);
+            const group = await this.checkCanCreateRegistrationInvitation(put, organization?.id ?? null);
 
             const invitation = new RegistrationInvitation();
             invitation.id = put.id;
-            invitation.organizationId = organization.id;
+            invitation.organizationId = group.organizationId;
             invitation.groupId = put.groupId;
             invitation.memberId = put.memberId;
 
@@ -125,12 +129,13 @@ export class PatchRegistrationInvitationsEndpoint extends Endpoint<Params, Query
     /**
      * Will throw if not allowed to invite.
      * @param invitation
-     * @param organizationId id of organization to invite for, should match the organizationId in the invitation
+     * @param organizationId organization scope of the request; when set, the group must belong to it (platform admins can invite without a scope)
+     * @returns the group to invite for
      */
-    private async checkCanCreateRegistrationInvitation(invitation: RegistrationInvitationRequest, organizationId: string) {
+    private async checkCanCreateRegistrationInvitation(invitation: RegistrationInvitationRequest, organizationId: string | null): Promise<Group> {
         const group = await Group.getByID(invitation.groupId);
 
-        if (!group || group.organizationId !== organizationId || !await Context.auth.canAccessGroup(group, PermissionLevel.Write)) {
+        if (!group || (organizationId !== null && group.organizationId !== organizationId) || !await Context.auth.canAccessGroup(group, PermissionLevel.Write)) {
             throw Context.auth.error($t(`%1ST`));
         }
 
@@ -147,7 +152,7 @@ export class PatchRegistrationInvitationsEndpoint extends Endpoint<Params, Query
 
         if (!member
             // in userMode 'organization' we can only invite members from the same organization
-            || (STAMHOOFD.userMode === 'organization' && member.organizationId !== organizationId)
+            || (STAMHOOFD.userMode === 'organization' && member.organizationId !== group.organizationId)
             // read access is suficient
             || !await Context.auth.canAccessMember(member, PermissionLevel.Read)
         ) {
@@ -163,5 +168,7 @@ export class PatchRegistrationInvitationsEndpoint extends Endpoint<Params, Query
                 human: $t('%1S2'),
             });
         }
+
+        return group;
     }
 }

package/src/endpoints/organization/dashboard/settlements/SettlementsSyncEndpoint.test.ts

@@ -1,12 +1,16 @@
 import { Request } from '@simonbackx/simple-endpoints';
+import { SimpleError } from '@simonbackx/simple-errors';
 import type { Organization, Token, User } from '@stamhoofd/models';
 import { OrganizationFactory, Payment, Token as TokenModel, UserFactory } from '@stamhoofd/models';
 import { Settlement } from '@stamhoofd/models/models/Settlement.js';
+import type { AbortSignal } from '@stamhoofd/queues';
 import { QueueHandler } from '@stamhoofd/queues';
 import { PaymentMethod, PaymentProvider, PaymentStatus } from '@stamhoofd/structures';
 import { STExpect } from '@stamhoofd/test-utils';
+import { vi } from 'vitest';
 
 import { StripeMocker } from '../../../../../tests/helpers/StripeMocker.js';
+import { SettlementSyncRunner } from '../../../../helpers/SettlementSyncRunner.js';
 import { testServer } from '../../../../../tests/helpers/TestServer.js';
 import { initMembershipOrganization } from '../../../../../tests/init/initMembershipOrganization.js';
 import { initPlatformAdmin } from '../../../../../tests/init/initPlatformAdmin.js';
@@ -88,6 +92,86 @@ describe('Endpoint.SettlementsSync', () => {
         expect(statusResponse.body).toEqual([]);
     });
 
+    const shutdown = () => {
+        QueueHandler.abortAll(new SimpleError({
+            code: 'SHUTDOWN',
+            message: 'Shutting down',
+            statusCode: 503,
+        }));
+    };
+
+    test('A sync that is canceled by a shutdown walks nothing and leaves no status behind', async () => {
+        const payout = stripeMocker.createPayout({ amount: 10000, arrivalDate: new Date(2026, 0, 20) });
+        stripeMocker.createBalanceTransaction({
+            type: 'stripe_fee',
+            amount: 10000,
+            created: new Date(2026, 0, 15),
+            payout: payout.id,
+            source: null,
+        });
+
+        // Occupy the queue, so the sync is still waiting its turn when the shutdown aborts it
+        let release = () => {};
+        const occupied = QueueHandler.schedule('settlement-sync', async () => {
+            await new Promise<void>((resolve) => {
+                release = resolve;
+            });
+        });
+
+        try {
+            const response = await post(membershipOrganization, adminToken);
+            expect(response.status).toBe(200);
+            expect((await getStatus(membershipOrganization, adminToken)).body).toHaveLength(1);
+
+            shutdown();
+        } finally {
+            release();
+        }
+
+        await occupied;
+        await QueueHandler.awaitAll();
+
+        expect(await Settlement.select().where('externalId', payout.id).count()).toBe(0);
+
+        // The status list may not keep a sync that never ran
+        expect((await getStatus(membershipOrganization, adminToken)).body).toEqual([]);
+    });
+
+    test('A shutdown interrupts a sync that is already walking', async () => {
+        let running: AbortSignal | null = null;
+        let stopWalking = () => {};
+
+        const spy = vi.spyOn(SettlementSyncRunner.prototype, 'run').mockImplementation(async ({ abort } = {}) => {
+            running = abort ?? null;
+
+            // Walk until the shutdown asks us to stop
+            await new Promise<void>((resolve) => {
+                stopWalking = resolve;
+                abort?.on('abort', () => resolve());
+            });
+            abort?.throwIfAborted();
+
+            return { feeMonths: 0, failedFeeMonths: 0, synced: 0, skipped: 0, failed: 0 };
+        });
+
+        try {
+            const response = await post(membershipOrganization, adminToken);
+            expect(response.status).toBe(200);
+            await vi.waitFor(() => expect(running).not.toBeNull());
+
+            shutdown();
+            await QueueHandler.awaitAll();
+        } finally {
+            // A failed assertion may not leave the walk (and the queue behind it) parked forever
+            stopWalking();
+            spy.mockRestore();
+        }
+
+        // The signal of the queue job reaches the runner, so the walk stops at its next safe point
+        expect(running!.isAborted).toBe(true);
+        expect((await getStatus(membershipOrganization, adminToken)).body).toEqual([]);
+    });
+
     test('A user without platform full access cannot run the sync', async () => {
         const user = await new UserFactory({ organization: membershipOrganization }).create();
         const token = await TokenModel.createToken(user);

package/src/endpoints/organization/dashboard/settlements/SettlementsSyncEndpoint.ts

@@ -86,17 +86,18 @@ export class SettlementsSyncEndpoint extends Endpoint<Params, Query, Body, Respo
         });
         SettlementsSyncEndpoint.queue.push(item);
 
-        QueueHandler.schedule('settlement-sync', async () => {
-            try {
-                const runner = new SettlementSyncRunner();
-                runner.callback = (summary) => {
-                    item.count = summary.synced + summary.skipped + summary.failed;
-                    item.failed = summary.failed + summary.failedFeeMonths;
-                };
-                await runner.run({ start, end, providers, stripe: { force } });
-            } finally {
-                SettlementsSyncEndpoint.queue.splice(SettlementsSyncEndpoint.queue.indexOf(item), 1);
-            }
+        // A shutdown aborts the queue: the run stops at its next safe point instead of holding up
+        // the restart, and the status list is cleaned up whether the run finished, was aborted, or
+        // was canceled before it started
+        QueueHandler.schedule('settlement-sync', async ({ abort }) => {
+            const runner = new SettlementSyncRunner();
+            runner.callback = (summary) => {
+                item.count = summary.synced + summary.skipped + summary.failed;
+                item.failed = summary.failed + summary.failedFeeMonths;
+            };
+            await runner.run({ start, end, providers, stripe: { force }, abort });
+        }).finally(() => {
+            SettlementsSyncEndpoint.queue = SettlementsSyncEndpoint.queue.filter(queued => queued !== item);
         }).catch(console.error);
 
         return new Response(undefined);

package/src/endpoints/organization/dashboard/webshops/PatchWebshopEndpoint.ts

@@ -9,6 +9,7 @@ import { Formatter, isReservedWebshopPathSegment } from '@stamhoofd/utility';
 
 import { Context } from '../../../../helpers/Context.js';
 import { RecordAnswerHelper } from '../../../../helpers/RecordAnswerHelper.js';
+import { WebshopCrowdfundingService } from '../../../../services/WebshopCrowdfundingService.js';
 
 type Params = { id: string };
 type Query = undefined;
@@ -226,6 +227,11 @@ export class PatchWebshopEndpoint extends Endpoint<Params, Query, Body, Response
                 throw e;
             }
 
+            if (request.body.meta?.crowdfunding !== undefined) {
+                // A changed crowdfunding configuration (e.g. just enabled) requires a recalculation of the cached amounts
+                await WebshopCrowdfundingService.updateWebshop(webshop);
+            }
+
             return new Response(PrivateWebshop.create(webshop));
         });
     }

package/src/endpoints/organization/dashboard/webshops/PatchWebshopOrdersEndpoint.ts

@@ -10,6 +10,7 @@ import { AuditLogSource, BalanceItemRelation, BalanceItemRelationType, BalanceIt
 import { Context } from '../../../../helpers/Context.js';
 import { ServiceFeeHelper } from '../../../../helpers/ServiceFeeHelper.js';
 import { AuditLogService } from '../../../../services/AuditLogService.js';
+import { BalanceItemService } from '../../../../services/BalanceItemService.js';
 import { OrderService } from '../../../../services/OrderService.js';
 import { PaymentService } from '../../../../services/PaymentService.js';
 import { shouldReserveUitpasNumbers, UitpasService } from '../../../../services/uitpas/UitpasService.js';
@@ -232,6 +233,9 @@ export class PatchWebshopOrdersEndpoint extends Endpoint<Params, Query, Body, Re
 
                         balanceItem.description = order.generateBalanceDescription(webshop);
                         await balanceItem.save();
+
+                        // Update the cached pricePending of the balance item, so the unresolved payment is visible
+                        await BalanceItemService.updatePaidAndPending([balanceItem]);
                     }
                 } catch (e) {
                     await order.deleteOrderBecauseOfCreationError();

package/src/endpoints/organization/webshops/PlaceOrderEndpoint.ts

@@ -15,6 +15,7 @@ import { Context } from '../../../helpers/Context.js';
 import { ServiceFeeHelper } from '../../../helpers/ServiceFeeHelper.js';
 import { StripeHelper } from '../../../helpers/StripeHelper.js';
 import { AuditLogService } from '../../../services/AuditLogService.js';
+import { BalanceItemService } from '../../../services/BalanceItemService.js';
 import { MollieService } from '../../../services/MollieService.js';
 import { OrderService } from '../../../services/OrderService.js';
 import { PaymentService } from '../../../services/PaymentService.js';
@@ -356,6 +357,9 @@ export class PlaceOrderEndpoint extends Endpoint<Params, Query, Body, ResponseBo
                     }
                 }
 
+                // Update the cached pricePending of the balance item, so the unresolved payment is visible
+                await BalanceItemService.updatePaidAndPending([balanceItem]);
+
                 return new Response(OrderResponse.create({
                     paymentUrl: paymentUrl,
                     paymentQRCode,

package/src/helpers/ApplicationFeeInvoicer.test.ts

@@ -1,3 +1,4 @@
+import { EmailMocker } from '@stamhoofd/email';
 import type { StripeAccount } from '@stamhoofd/models';
 import { BalanceItem, BalanceItemPayment, Organization, OrganizationFactory, Payment } from '@stamhoofd/models';
 import { ApplicationFee } from '@stamhoofd/models/models/ApplicationFee.js';
@@ -15,6 +16,7 @@ import { initMembershipOrganization } from '../../tests/init/initMembershipOrgan
 import { ApplicationFeeService, LEGACY_FEE_PAYMENT_REFERENCE_PREFIX } from '../services/ApplicationFeeService.js';
 import { SettlementService } from '../services/SettlementService.js';
 import { ApplicationFeeInvoicer } from './ApplicationFeeInvoicer.js';
+import { WebmasterReport } from './WebmasterReport.js';
 
 describe('ApplicationFeeInvoicer', () => {
     const stripeMocker = new StripeMocker();
@@ -262,8 +264,18 @@ describe('ApplicationFeeInvoicer', () => {
         await createFee(organization, stripeAccount, { amount: 30_00 });
         await createFee(organization, broken, { amount: 40_00 });
 
-        // Deleting the account clears payingStripeAccountId: that group can't be billed anymore
-        await broken.delete();
+        // A month the legacy invoicer billed may never be billed again: that group throws
+        const legacy = new Payment();
+        legacy.organizationId = membershipOrganization.id;
+        legacy.payingOrganizationId = organization.id;
+        legacy.stripeAccountId = broken.id;
+        legacy.method = PaymentMethod.AccountDeductions;
+        legacy.provider = PaymentProvider.Stripe;
+        legacy.status = PaymentStatus.Succeeded;
+        legacy.reference = LEGACY_FEE_PAYMENT_REFERENCE_PREFIX + '2024-07-01';
+        legacy.price = 40_00;
+        legacy.paidAt = occurredAt;
+        await legacy.save();
 
         await invoiceMonth();
 
@@ -272,14 +284,63 @@ describe('ApplicationFeeInvoicer', () => {
         expect(payments[0].price).toBe(30_00);
     });
 
+    test('fees without the Stripe account they were deducted from are skipped, not retried forever', async () => {
+        const { organization, stripeAccount } = await init();
+        const removed = await stripeMocker.createStripeAccount(organization.id);
+
+        await createFee(organization, stripeAccount, { amount: 30_00 });
+        const orphaned = await createFee(organization, removed, { amount: 40_00 });
+
+        // Deleting the account row clears payingStripeAccountId: that fee can no longer be checked
+        // against what the legacy invoicer billed per account, so it is not billed at all
+        await removed.delete();
+
+        await WebmasterReport.group('Overslaan applicatiekosten', async () => {
+            await invoiceMonth();
+        });
+
+        const payments = await getFeePayments(organization);
+        expect(payments).toHaveLength(1);
+        expect(payments[0].price).toBe(30_00);
+        expect((await ApplicationFee.getByID(orphaned.id))!.balanceItemId).toBeNull();
+
+        // Skipping is silent here: the sync that stored the fee already reported it, and this run
+        // repeats every night
+        const emails = (await EmailMocker.transactional.getSucceededEmails()).filter(e => e.subject.startsWith('Overslaan applicatiekosten'));
+        expect(emails).toHaveLength(0);
+    });
+
     test('charges of a billed fee keep pointing at the deduction row', async () => {
         const { organization, stripeAccount } = await init();
         const fee = await createFee(organization, stripeAccount);
 
         await invoiceMonth();
 
-        const charge = await SettlementCharge.getByID(fee.settlementChargeId);
+        const charge = await SettlementCharge.getByID(fee.settlementChargeId!);
         expect(charge).toBeDefined();
         expect(charge!.amount).toBe(-30_00);
     });
+
+    test('fees of a deleted organization are never billed, and do not block the other accounts', async () => {
+        const { organization, stripeAccount } = await init();
+        const { organization: other, stripeAccount: otherAccount } = await init();
+
+        const orphaned = await createFee(organization, stripeAccount, { amount: 30_00 });
+        await createFee(other, otherAccount, { amount: 40_00 });
+
+        // Takes the Stripe account and the deduction charge with it, but not our income
+        await organization.delete();
+
+        await invoiceMonth();
+
+        const payments = await getFeePayments(other);
+        expect(payments).toHaveLength(1);
+        expect(payments[0].price).toBe(40_00);
+
+        const stored = await ApplicationFee.getByID(orphaned.id);
+        expect(stored).toBeDefined();
+        expect(stored!.payingOrganizationId).toBeNull();
+        expect(stored!.settlementChargeId).toBeNull();
+        expect(stored!.balanceItemId).toBeNull();
+    });
 });

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

@@ -3,10 +3,14 @@ import { MolliePayment, OrganizationFactory, Payment } from '@stamhoofd/models';
 import { PaymentSettlement } from '@stamhoofd/models/models/PaymentSettlement.js';
 import { Settlement } from '@stamhoofd/models/models/Settlement.js';
 import { SettlementCharge } from '@stamhoofd/models/models/SettlementCharge.js';
+import { AbortSignal } from '@stamhoofd/queues';
 import { PaymentMethod, PaymentProvider, PaymentStatus, PaymentType } from '@stamhoofd/structures';
 import { SettlementChargeType } from '@stamhoofd/structures/settlements/SettlementChargeType.js';
+import { STExpect } from '@stamhoofd/test-utils';
+import { vi } from 'vitest';
 import type { MollieMockPayment, MollieMockRefund } from '../../tests/helpers/MollieMocker.js';
 import { MollieMocker } from '../../tests/helpers/MollieMocker.js';
+import { SettlementService } from '../services/SettlementService.js';
 import { MollieSettlementSync } from './MollieSettlementSync.js';
 import type { SettlementSyncSummary } from './ProviderSettlementSyncRunner.js';
 
@@ -340,6 +344,45 @@ describe('Helper.MollieSettlementSync', () => {
         expect(summary.failed).toBe(0);
     });
 
+    test('An interrupted walk gives up its synced state without counting a failure', async () => {
+        const { token, mockPayment, mockRefund } = await init();
+
+        const settlement = mollieMocker.createSettlement({ payments: [mockPayment], refunds: [mockRefund], value: '30.00', settledAt: new Date(2026, 2, 3) });
+
+        await runCron(token);
+        expect((await Settlement.select().where('externalId', settlement.id).first(true)).syncedAt).not.toBeNull();
+
+        // Older, so the newest-first walk only reaches it after the one it is interrupted in
+        const untouched = mollieMocker.createSettlement({ payments: [mockPayment], value: '50.00', settledAt: new Date(2026, 2, 2) });
+
+        // Abort while the walk stores its first entry, so the settlement is only walked halfway
+        const abort = new AbortSignal();
+        const upsertPaymentLine = SettlementService.upsertPaymentLine.bind(SettlementService);
+        const spy = vi.spyOn(SettlementService, 'upsertPaymentLine').mockImplementation(async (row, data) => {
+            abort.abort();
+            return await upsertPaymentLine(row, data);
+        });
+
+        const summary: SettlementSyncSummary = { feeMonths: 0, failedFeeMonths: 0, synced: 0, skipped: 0, failed: 0 };
+        try {
+            await expect(new MollieSettlementSync({ token }).syncSettlements({
+                start: new Date(2020, 0, 1),
+                summary,
+                abort,
+            })).rejects.toThrow(STExpect.simpleError({ code: 'queue-aborted' }));
+        } finally {
+            spy.mockRestore();
+        }
+
+        const row = await Settlement.select().where('externalId', settlement.id).first(true);
+        expect(row.syncedAt).toBeNull();
+        expect(row.syncFailureCount).toBe(0);
+        expect(summary).toMatchObject({ synced: 0, failed: 0 });
+
+        // The walk stopped at the settlement it was in: the next one was never started
+        expect(await Settlement.select().where('externalId', untouched.id).count()).toBe(0);
+    });
+
     test('An unlinked refund entry in a settlement is skipped without affecting the known refund', async () => {
         const { token, refundPayment, mockPayment, mockRefund } = await init();
 

package/src/helpers/MollieSettlementSync.ts

@@ -1,6 +1,7 @@
 import type { MollieToken } from '@stamhoofd/models';
 import { MolliePayment, Payment } from '@stamhoofd/models';
 import type { Settlement } from '@stamhoofd/models/models/Settlement.js';
+import type { AbortSignal } from '@stamhoofd/queues';
 import { PaymentProvider } from '@stamhoofd/structures';
 import { SettlementChargeType } from '@stamhoofd/structures/settlements/SettlementChargeType.js';
 import { SettlementStatus } from '@stamhoofd/structures/settlements/SettlementStatus.js';
@@ -47,6 +48,11 @@ type MollieSettlement = {
 type SettlementSyncState = {
     settlementRow: Settlement;
     reported: ReportedRows;
+
+    /**
+     * Stops the walk at the next entry (a restart).
+     */
+    abort: AbortSignal;
 };
 
 /**
@@ -89,14 +95,17 @@ export class MollieSettlementSync {
     /**
      * Walk the settlements newest first, until they settle before `start`.
      */
-    async syncSettlements({ start, end = new Date(), summary }: {
+    async syncSettlements({ start, end = new Date(), summary, abort }: {
         start: Date;
         end?: Date;
         summary?: SettlementSyncSummary;
+        abort?: AbortSignal;
     }): Promise<void> {
         let url: string | null = 'https://api.mollie.com/v2/settlements?limit=250';
 
         while (url) {
+            abort?.throwIfAborted();
+
             const request = await this.#get(url);
 
             if (request.status !== 200) {
@@ -112,6 +121,8 @@ export class MollieSettlementSync {
             }
 
             for (const settlement of settlements) {
+                abort?.throwIfAborted();
+
                 if (settlement.settledAt === null) {
                     // Skip: this is the open settlement
                     continue;
@@ -134,11 +145,14 @@ export class MollieSettlementSync {
                 }
 
                 try {
-                    await SettlementService.lock(PaymentProvider.Mollie, settlement.id, () => this.#syncSettlement(settlement));
+                    await SettlementService.lock(PaymentProvider.Mollie, settlement.id, signal => this.#syncSettlement(settlement, signal), { abort });
                     if (summary) {
                         summary.synced += 1;
                     }
                 } catch (e) {
+                    // An interrupted settlement is not a failing settlement
+                    abort?.throwIfAborted();
+
                     console.error('Sync of Mollie settlement ' + settlement.id + ' failed', e);
                     if (summary) {
                         summary.failed += 1;
@@ -163,7 +177,7 @@ export class MollieSettlementSync {
         });
     }
 
-    async #syncSettlement(settlement: MollieSettlement) {
+    async #syncSettlement(settlement: MollieSettlement, abort: AbortSignal) {
         const settlementRow = await SettlementService.upsertSettlement({
             provider: PaymentProvider.Mollie,
             externalId: settlement.id,
@@ -178,6 +192,7 @@ export class MollieSettlementSync {
         const state: SettlementSyncState = {
             settlementRow,
             reported: new ReportedRows(),
+            abort,
         };
 
         try {
@@ -200,7 +215,13 @@ export class MollieSettlementSync {
                 transactionCount: state.reported.paymentLineExternalIds.size + state.reported.chargeExternalIds.size,
             });
         } catch (e) {
-            await SettlementService.markSyncFailed(settlementRow);
+            // A walk that was interrupted stored only part of the settlement: it has to be walked
+            // again, but it didn't fail
+            if (abort.isAborted) {
+                await SettlementService.markSyncInterrupted(settlementRow);
+            } else {
+                await SettlementService.markSyncFailed(settlementRow);
+            }
             throw e;
         }
     }
@@ -265,6 +286,10 @@ export class MollieSettlementSync {
             const entries = request.data._embedded[resource] as MollieSettlementEntryJSON[];
 
             for (const entry of entries) {
+                // Between two entries is a safe point to stop: the settlement only claims to be
+                // synced after the sweep, so an interrupted walk is re-walked from the start
+                state.abort.throwIfAborted();
+
                 await this.#applySettlementToPayment(settlement, entry.id, state);
             }
 

package/src/helpers/MollieSettlementSyncRunner.ts

@@ -10,7 +10,7 @@ import type { ProviderSettlementSyncRunner, ProviderSyncRunOptions } from './Pro
  * (STAMHOOFD.MOLLIE_ORGANIZATION_TOKEN for the platform, a MollieToken row per organization).
  */
 export class MollieSettlementSyncRunner implements ProviderSettlementSyncRunner {
-    async run({ start, end, summary, onProgress }: ProviderSyncRunOptions): Promise<void> {
+    async run({ start, end, summary, onProgress, abort }: ProviderSyncRunOptions): Promise<void> {
         const accessToken = STAMHOOFD.MOLLIE_ORGANIZATION_TOKEN;
         if (!accessToken) {
             console.error('Missing mollie organization token');
@@ -24,8 +24,11 @@ export class MollieSettlementSyncRunner implements ProviderSettlementSyncRunner
                 // A plain access token without a refresh flow: the future expiry keeps
                 // refreshIfNeeded from attempting one
                 token.expiresOn = new Date(new Date().getTime() + 24 * 60 * 60 * 1000);
-                await new MollieSettlementSync({ token }).syncSettlements({ start, end, summary });
+                await new MollieSettlementSync({ token }).syncSettlements({ start, end, summary, abort });
             } catch (e) {
+                // An interrupted account is not a failing account
+                abort.throwIfAborted();
+
                 console.error(e);
                 summary.failed += 1;
             }
@@ -34,6 +37,8 @@ export class MollieSettlementSyncRunner implements ProviderSettlementSyncRunner
 
         const mollieTokens = await MollieToken.all();
         for (const token of mollieTokens) {
+            abort.throwIfAborted();
+
             // Tokens created before the settlements permission was added to the OAuth scope
             // cannot read settlements
             if (token.createdAt < new Date(2021, 8 /* september! */, 8)) {
@@ -42,8 +47,10 @@ export class MollieSettlementSyncRunner implements ProviderSettlementSyncRunner
             }
 
             try {
-                await new MollieSettlementSync({ token }).syncSettlements({ start, end, summary });
+                await new MollieSettlementSync({ token }).syncSettlements({ start, end, summary, abort });
             } catch (e) {
+                abort.throwIfAborted();
+
                 console.error(e);
                 summary.failed += 1;
             }