@stamhoofd/backend 2.142.0 → 2.143.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.142.0",
+    "version": "2.143.0",
     "type": "module",
     "main": "./dist/index.js",
     "exports": {
@@ -65,20 +65,20 @@
         "@simonbackx/simple-errors": "1.5.0",
         "@simonbackx/simple-logging": "1.0.1",
         "@simplewebauthn/server": "13.3.2",
-        "@stamhoofd/backend-env": "2.142.0",
-        "@stamhoofd/backend-i18n": "2.142.0",
-        "@stamhoofd/backend-middleware": "2.142.0",
-        "@stamhoofd/crons": "2.142.0",
-        "@stamhoofd/email": "2.142.0",
-        "@stamhoofd/excel-writer": "2.142.0",
-        "@stamhoofd/logging": "2.142.0",
-        "@stamhoofd/models": "2.142.0",
-        "@stamhoofd/object-differ": "2.142.0",
-        "@stamhoofd/queues": "2.142.0",
-        "@stamhoofd/sql": "2.142.0",
-        "@stamhoofd/structures": "2.142.0",
-        "@stamhoofd/types": "2.142.0",
-        "@stamhoofd/utility": "2.142.0",
+        "@stamhoofd/backend-env": "2.143.0",
+        "@stamhoofd/backend-i18n": "2.143.0",
+        "@stamhoofd/backend-middleware": "2.143.0",
+        "@stamhoofd/crons": "2.143.0",
+        "@stamhoofd/email": "2.143.0",
+        "@stamhoofd/excel-writer": "2.143.0",
+        "@stamhoofd/logging": "2.143.0",
+        "@stamhoofd/models": "2.143.0",
+        "@stamhoofd/object-differ": "2.143.0",
+        "@stamhoofd/queues": "2.143.0",
+        "@stamhoofd/sql": "2.143.0",
+        "@stamhoofd/structures": "2.143.0",
+        "@stamhoofd/types": "2.143.0",
+        "@stamhoofd/utility": "2.143.0",
         "archiver": "7.0.1",
         "argon2": "0.44.0",
         "axios": "1.18.1",
@@ -102,7 +102,7 @@
         "uuid": "14.0.1"
     },
     "devDependencies": {
-        "@stamhoofd/test-utils": "2.142.0",
+        "@stamhoofd/test-utils": "2.143.0",
         "@types/cookie": "0.6.0",
         "@types/luxon": "3.7.2",
         "@types/mailparser": "3.4.6",
@@ -117,5 +117,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "2903821fe8196e3bb194da193aaf1cda2c3bf076"
+    "gitHead": "8959c4f720d332be9769e033d40bb25f9e6aa322"
 }

package/src/boot.ts

@@ -16,6 +16,7 @@ import { Platform } from '@stamhoofd/models';
 import { QueueHandler } from '@stamhoofd/queues';
 import { resumeEmails } from './helpers/EmailResumer.js';
 import { GlobalHelper } from './helpers/GlobalHelper.js';
+import { waitUntilDeadline } from './helpers/waitUntilDeadline.js';
 import { SetupStepUpdater } from './helpers/SetupStepUpdater.js';
 import { ContextMiddleware } from './middleware/ContextMiddleware.js';
 import { TenantScopeMiddleware } from './middleware/TenantScopeMiddleware.js';
@@ -29,6 +30,7 @@ import { UitpasService } from './services/uitpas/UitpasService.js';
 import { UniqueMemberNumberService } from './services/UniqueMemberNumberService.js';
 import { UniqueUserService } from './services/UniqueUserService.js';
 import { QueryableModel, SQLLogger } from '@stamhoofd/sql';
+import { WebshopCrowdfundingService } from './services/WebshopCrowdfundingService.js';
 
 process.on('unhandledRejection', (error: Error) => {
     console.error('unhandledRejection');
@@ -51,6 +53,13 @@ if (new Date().getTimezoneOffset() !== 0) {
     throw new Error('Process should always run in UTC timezone');
 }
 
+/**
+ * How long a shutdown waits for the running crons, queue jobs and emails together. Aborting them is
+ * a request: a job that never checks it, or that hangs on a network call, may not keep the restart
+ * waiting. Everything left behind runs again after the restart.
+ */
+const MAXIMUM_SHUTDOWN_WAIT = 29 * 1000;
+
 const seeds = async (options: { shutdown: () => Promise<void> }) => {
     if (await checkReadOnly()) {
         console.error(new StyledText(`[SEEDS] `).addClass('migration', 'tag'), new StyledText('MySQL is in read-only mode: Seeds are disabled.').addClass('error'));
@@ -210,13 +219,15 @@ export const boot = async (options: { killProcess: boolean }) => {
         if (shuttingDown) {
             return;
         }
+        const deadline = new Date(Date.now() + MAXIMUM_SHUTDOWN_WAIT);
+
         shuttingDown = true;
         QueryableModel.shutdownMigrations = true;
         productionLog('Shutting down...');
         // Disable keep alive
         routerServer.defaultHeaders = Object.assign(routerServer.defaultHeaders, { Connection: 'close' });
         if (routerServer.server) {
-            routerServer.server.headersTimeout = 5000;
+            routerServer.server.headersTimeout = 1000;
             routerServer.server.keepAliveTimeout = 1;
         }
 
@@ -236,27 +247,31 @@ export const boot = async (options: { killProcess: boolean }) => {
             console.error('Failed to stop HTTP server:');
             console.error(err);
         }
+        const shutdownError = new SimpleError({
+            code: 'SHUTDOWN',
+            message: 'Shutting down',
+            statusCode: 503,
+        });
+        QueueHandler.abortAll(shutdownError);
 
-        await BalanceItemService.flushAll();
-        await waitForCrons();
-        QueueHandler.abortAll(
-            new SimpleError({
-                code: 'SHUTDOWN',
-                message: 'Shutting down',
-                statusCode: 503,
-            }),
-        );
-        await QueueHandler.awaitAll();
+        await Promise.allSettled([
+            BalanceItemService.flushAll(),
+            WebshopCrowdfundingService.flush(),
+            waitUntilDeadline(waitForCrons(), { deadline, description: 'crons' }),
+            waitUntilDeadline(QueueHandler.awaitAll(), { deadline, description: 'queues' }),
+        ]);
 
-        try {
+        // Any last queues started in above jobs
+        QueueHandler.abortAll(shutdownError);
+        await waitUntilDeadline(QueueHandler.awaitAll(), { deadline, description: 'queues' });
+
+        // Wait for emails
+        await waitUntilDeadline((async () => {
             while (Email.currentQueue.length > 0) {
                 console.log(`${Email.currentQueue.length} emails still in queue. Waiting 500ms...`);
                 await sleep(500);
             }
-        } catch (err) {
-            console.error('Failed to wait for emails to finish:');
-            console.error(err);
-        }
+        })(), { deadline, description: 'emails' });
 
         try {
             await Database.end();

package/src/crons/settlement-sync.test.ts

@@ -1,11 +1,15 @@
 import { EmailMocker } from '@stamhoofd/email';
 import type { Organization } from '@stamhoofd/models';
 import { OrganizationFactory } from '@stamhoofd/models';
+import { QueueHandler } from '@stamhoofd/queues';
 import { PaymentProvider } from '@stamhoofd/structures';
+import { STExpect, TestUtils } from '@stamhoofd/test-utils';
 import { v4 as uuidv4 } from 'uuid';
+import { vi } from 'vitest';
 
+import { SettlementSyncRunner } from '../helpers/SettlementSyncRunner.js';
 import { SettlementService } from '../services/SettlementService.js';
-import { reportProblemSettlements } from './settlement-sync.js';
+import { reportProblemSettlements, syncSettlements } from './settlement-sync.js';
 
 describe('Cron.settlement-sync', () => {
     let organization: Organization;
@@ -36,4 +40,58 @@ describe('Cron.settlement-sync', () => {
         const emails = await EmailMocker.transactional.getSucceededEmails();
         expect(emails.find(e => e.subject.startsWith('Uitbetalingen met problemen'))).toBeDefined();
     });
+
+    describe('The nightly run', () => {
+        /**
+         * The run only starts between 5 and 6 AM Brussels time, and remembers the day it ran: every
+         * test needs its own day.
+         */
+        const arriveAt5AM = (dayOfMarch: number) => {
+            vi.setSystemTime(new Date(Date.UTC(2026, 2, dayOfMarch, 4, 30)));
+        };
+
+        beforeEach(() => {
+            TestUtils.setEnvironment('environment', 'production');
+            vi.useFakeTimers({ shouldAdvanceTime: true, toFake: ['Date'] });
+        });
+
+        afterEach(() => {
+            vi.useRealTimers();
+            vi.restoreAllMocks();
+        });
+
+        test('runs on the same queue as the manual sync, and only once a day', async () => {
+            arriveAt5AM(10);
+
+            const runs: string[][] = [];
+            vi.spyOn(SettlementSyncRunner.prototype, 'run').mockImplementation(async () => {
+                // Nested in the queue of the manual sync, so the two never walk at once
+                runs.push(QueueHandler.asyncLocalStorage.getStore() ?? []);
+                return { feeMonths: 0, failedFeeMonths: 0, synced: 0, skipped: 0, failed: 0 };
+            });
+
+            await syncSettlements();
+            await syncSettlements();
+
+            expect(runs).toEqual([['settlement-sync']]);
+        });
+
+        test('an interrupted run is not remembered as the sync of this day', async () => {
+            arriveAt5AM(11);
+
+            const spy = vi.spyOn(SettlementSyncRunner.prototype, 'run').mockImplementation(async ({ abort } = {}) => {
+                abort?.abort();
+                abort?.throwIfAborted();
+                return { feeMonths: 0, failedFeeMonths: 0, synced: 0, skipped: 0, failed: 0 };
+            });
+
+            await expect(syncSettlements()).rejects.toThrow(STExpect.simpleError({ code: 'queue-aborted' }));
+
+            // A restart may not skip the sync of this day: the next tick starts over
+            spy.mockResolvedValue({ feeMonths: 0, failedFeeMonths: 0, synced: 0, skipped: 0, failed: 0 });
+            await syncSettlements();
+
+            expect(spy).toHaveBeenCalledTimes(2);
+        });
+    });
 });

package/src/crons/settlement-sync.ts

@@ -3,6 +3,7 @@
 import { registerCron } from '@stamhoofd/crons';
 import { Email } from '@stamhoofd/email';
 import { Settlement } from '@stamhoofd/models/models/Settlement.js';
+import { QueueHandler } from '@stamhoofd/queues';
 import { PaymentProvider } from '@stamhoofd/structures';
 import { SettlementStatus } from '@stamhoofd/structures/settlements/SettlementStatus.js';
 import { Formatter } from '@stamhoofd/utility';
@@ -25,7 +26,10 @@ const MAXIMUM_PENDING_FEES_AGE_MS = 31 * 24 * 60 * 60 * 1000;
 
 let lastSettlementSync: Date | null = null;
 
-async function syncSettlements() {
+/**
+ * Exported for tests only.
+ */
+export async function syncSettlements() {
     if (STAMHOOFD.environment !== 'production') {
         return;
     }
@@ -46,15 +50,22 @@ async function syncSettlements() {
 
     const start = new Date(today.getTime() - SYNC_WINDOW_DAYS * 24 * 60 * 60 * 1000);
 
-    const runner = new SettlementSyncRunner();
-    await runner.run({
-        start,
-        providers: [PaymentProvider.Stripe, PaymentProvider.Mollie],
-        stripe: { retryUnsynced: true },
+    // The same queue as the manual backfill: the two never walk the same period at once, and a
+    // shutdown aborts this run instead of waiting for the whole window. An aborted run throws, so
+    // it is not remembered as the sync of this day: a later tick within the hour runs it again,
+    // and otherwise the next day re-walks the same window anyway
+    await QueueHandler.schedule('settlement-sync', async ({ abort }) => {
+        const runner = new SettlementSyncRunner();
+        await runner.run({
+            start,
+            providers: [PaymentProvider.Stripe, PaymentProvider.Mollie],
+            stripe: { retryUnsynced: true },
+            abort,
+        });
+
+        await reportProblemSettlements();
     });
 
-    await reportProblemSettlements();
-
     lastSettlementSync = new Date();
 }
 

package/src/endpoints/admin/organizations/PatchOrganizationsEndpoint.ts

@@ -74,7 +74,7 @@ export class PatchOrganizationsEndpoint extends Endpoint<Params, Query, Body, Re
                 throw new SimpleError({
                     code: 'organization_has_financial_records',
                     message: 'Organization is still referenced as paying organization',
-                    human: $t('Er zijn nog openstaande bedragen, betalingen, transactiekosten of facturen waarvoor {organization} moet betalen of betaald heeft. Die gegevens mogen niet verloren gaan.', { organization: organization.name }),
+                    human: $t('%Zks', { organization: organization.name }),
                 });
             }
 

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/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);
             }