@stamhoofd/backend 2.126.2 → 2.127.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.126.2",
+    "version": "2.127.0",
     "type": "module",
     "main": "./dist/index.js",
     "exports": {
@@ -57,20 +57,20 @@
         "@simonbackx/simple-endpoints": "1.21.1",
         "@simonbackx/simple-errors": "1.5.0",
         "@simonbackx/simple-logging": "1.0.1",
-        "@stamhoofd/backend-env": "2.126.2",
-        "@stamhoofd/backend-i18n": "2.126.2",
-        "@stamhoofd/backend-middleware": "2.126.2",
-        "@stamhoofd/crons": "2.126.2",
-        "@stamhoofd/email": "2.126.2",
-        "@stamhoofd/excel-writer": "2.126.2",
-        "@stamhoofd/logging": "2.126.2",
-        "@stamhoofd/models": "2.126.2",
-        "@stamhoofd/object-differ": "2.126.2",
-        "@stamhoofd/queues": "2.126.2",
-        "@stamhoofd/sql": "2.126.2",
-        "@stamhoofd/structures": "2.126.2",
-        "@stamhoofd/types": "2.126.2",
-        "@stamhoofd/utility": "2.126.2",
+        "@stamhoofd/backend-env": "2.127.0",
+        "@stamhoofd/backend-i18n": "2.127.0",
+        "@stamhoofd/backend-middleware": "2.127.0",
+        "@stamhoofd/crons": "2.127.0",
+        "@stamhoofd/email": "2.127.0",
+        "@stamhoofd/excel-writer": "2.127.0",
+        "@stamhoofd/logging": "2.127.0",
+        "@stamhoofd/models": "2.127.0",
+        "@stamhoofd/object-differ": "2.127.0",
+        "@stamhoofd/queues": "2.127.0",
+        "@stamhoofd/sql": "2.127.0",
+        "@stamhoofd/structures": "2.127.0",
+        "@stamhoofd/types": "2.127.0",
+        "@stamhoofd/utility": "2.127.0",
         "archiver": "7.0.1",
         "axios": "1.16.0",
         "base-x": "3.0.11",
@@ -91,7 +91,7 @@
         "stripe": "16.12.0"
     },
     "devDependencies": {
-        "@stamhoofd/test-utils": "2.126.2",
+        "@stamhoofd/test-utils": "2.127.0",
         "@types/cookie": "0.6.0",
         "@types/luxon": "3.7.1",
         "@types/mailparser": "3.4.6",
@@ -107,5 +107,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "ccfe4c07df84adf3b7720912aac11cba65811358"
+    "gitHead": "c3c61a7728293f5fe7b4b639f95b3cc79166265f"
 }

package/src/crons/index.ts

@@ -6,6 +6,7 @@ import './balance-emails.js';
 import './delete-old-email-drafts.js';
 import './delete-archived-data.js';
 import './mollie-chargebacks.js';
+import './mollie-refunds.js';
 import './invoices.js';
 import './service-fees.js';
 import './members-fees.js';

package/src/crons/invoices.ts

@@ -23,7 +23,7 @@ async function invoices() {
         return;
     }
 
-    if (isOutside('03:00', '10:00')) {
+    if (isOutside('03:00', '10:00') && STAMHOOFD.environment !== 'development') {
         return;
     }
 
@@ -52,10 +52,10 @@ async function createInvoicesFor(organization: Organization) {
     const today = Formatter.luxon();
     const startDate = today.day <= 15 ? today.minus({ month: 2 }).startOf('month') : today.minus({ month: 1 }).startOf('month');
 
-    // Don't invoice below 1 euro - unless we reached the timeout date for invoices (end of month + 15 days - 3 days margin)
-    const invoiceLimit = STAMHOOFD.environment === 'development' ? 0 : 1_0000;
+    // Don't invoice below 10 euro - unless we reached the timeout date for invoices (end of month + 15 days - 5 days margin)
+    const invoiceLimit = STAMHOOFD.environment === 'development' ? 0 : 10_0000;
     function getPaymentTimeoutDate(p: Payment) {
-        return Formatter.luxon(p.paidAt ?? p.createdAt).plus({ month: 1 }).set({ day: 15 - 3 }).startOf('day').toJSDate();
+        return Formatter.luxon(p.paidAt ?? p.createdAt).plus({ month: 1 }).set({ day: 10 }).startOf('day').toJSDate();
     }
 
     console.log('Fetching all payments between ' + Formatter.dateTime(startDate.toJSDate()) + ' and now for ' + organization.name);
@@ -80,8 +80,7 @@ async function createInvoicesFor(organization: Organization) {
         const blob = {
             // Grouping by payingOrganizationId avoid privacy issues and data leaks
             payingOrganizationId: payment.payingOrganizationId ?? null,
-            vatNumber: payment.customer?.company?.VATNumber,
-            companyNumber: payment.customer?.company?.companyNumber,
+            vatNumber: Formatter.slugVATNumber(payment.customer?.company?.VATNumber ?? payment.customer?.company?.companyNumber ?? ''),
             // Name and adress is ignored, because subject to changes
         };
         const id = JSON.stringify(blob);

package/src/crons/mollie-refunds.test.ts

@@ -0,0 +1,310 @@
+import type { Organization } from '@stamhoofd/models';
+import { BalanceItem, BalanceItemFactory, BalanceItemPayment, MolliePayment, OrganizationFactory, Payment } from '@stamhoofd/models';
+import { PaymentMethod, PaymentProvider, PaymentStatus, PaymentType } from '@stamhoofd/structures';
+import type { MollieMockPayment } from '../../tests/helpers/MollieMocker.js';
+import { MollieMocker } from '../../tests/helpers/MollieMocker.js';
+import { MollieService } from '../services/MollieService.js';
+import { checkMollieRefundsFor, MOLLIE_REFUNDS_MINIMUM_DATE } from './mollie-refunds.js';
+
+describe('Cron.mollie-refunds', () => {
+    let mollieMocker: MollieMocker;
+
+    beforeAll(() => {
+        mollieMocker = new MollieMocker();
+        mollieMocker.start();
+    });
+
+    afterAll(() => {
+        mollieMocker.stop();
+    });
+
+    beforeEach(() => {
+        mollieMocker.reset();
+    });
+
+    /**
+     * Create an organization with a Mollie token and a succeeded Mollie payment
+     * for the given balance item prices.
+     */
+    const init = async ({ prices = [50_0000] }: { prices?: number[] } = {}) => {
+        const organization = await new OrganizationFactory({}).create();
+        await mollieMocker.setupToken(organization);
+
+        const balanceItems: BalanceItem[] = [];
+        let price = 0;
+        for (const itemPrice of prices) {
+            balanceItems.push(await new BalanceItemFactory({
+                organizationId: organization.id,
+                amount: 1,
+                unitPrice: itemPrice,
+                pricePaid: itemPrice,
+            }).create());
+            price += itemPrice;
+        }
+
+        const payment = new Payment();
+        payment.organizationId = organization.id;
+        payment.method = PaymentMethod.Bancontact;
+        payment.provider = PaymentProvider.Mollie;
+        payment.status = PaymentStatus.Succeeded;
+        payment.type = PaymentType.Payment;
+        payment.price = price;
+        payment.paidAt = new Date();
+        await payment.save();
+
+        for (const [index, balanceItem] of balanceItems.entries()) {
+            const balanceItemPayment = new BalanceItemPayment();
+            balanceItemPayment.balanceItemId = balanceItem.id;
+            balanceItemPayment.paymentId = payment.id;
+            balanceItemPayment.organizationId = organization.id;
+            balanceItemPayment.price = prices[index];
+            await balanceItemPayment.save();
+        }
+
+        const mockPayment: MollieMockPayment = {
+            id: mollieMocker.createId('tr'),
+            status: 'paid',
+            amount: { currency: 'EUR', value: (Math.round(price / 100) / 100).toFixed(2) },
+            internalPaymentId: payment.id,
+            redirectUrl: null,
+            sequenceType: 'oneoff',
+            customerId: null,
+            mandateId: null,
+            isCancelable: false,
+            details: null,
+        };
+        mollieMocker.payments.push(mockPayment);
+
+        const molliePayment = new MolliePayment();
+        molliePayment.paymentId = payment.id;
+        molliePayment.mollieId = mockPayment.id;
+        await molliePayment.save();
+
+        return { organization, balanceItems, payment, mockPayment };
+    };
+
+    const runCron = async (organization: Organization) => {
+        const service = await MollieService.create({ sellingOrganization: organization });
+        expect(service).not.toBeNull();
+        await checkMollieRefundsFor(service!, false);
+    };
+
+    const getRefundPayments = async (payment: Payment) => {
+        return await Payment.select().where('reversingPaymentId', payment.id).fetch();
+    };
+
+    test('A refund created in the Mollie dashboard is registered pending and reconciled once executed', async () => {
+        const { organization, balanceItems, payment, mockPayment } = await init();
+
+        const mockRefund = mollieMocker.createRefund(mockPayment);
+        await runCron(organization);
+
+        // Mollie still has to execute the refund, so it is registered as pending
+        const refunds = await getRefundPayments(payment);
+        expect(refunds).toHaveLength(1);
+        expect(refunds[0]).toMatchObject({
+            type: PaymentType.Refund,
+            price: -50_0000,
+            status: PaymentStatus.Pending,
+            method: PaymentMethod.Bancontact,
+            provider: PaymentProvider.Mollie,
+        });
+
+        // Linked so it won't get registered twice
+        const link = await MolliePayment.select().where('mollieId', mockRefund.id).first(false);
+        expect(link).not.toBeNull();
+        expect(link!.paymentId).toBe(refunds[0].id);
+
+        // Running the cron again does not create a duplicate
+        await runCron(organization);
+        expect(await getRefundPayments(payment)).toHaveLength(1);
+
+        // Nothing is refunded yet
+        let updatedSource = await Payment.getByID(payment.id);
+        expect(updatedSource!.refundedAmount).toBe(0);
+        expect(updatedSource!.pendingRefundAmount).toBe(-50_0000);
+
+        // Mollie executes the refund: the next cron run marks it as succeeded
+        mockRefund.status = 'refunded';
+        await runCron(organization);
+
+        const updatedRefund = await Payment.getByID(refunds[0].id);
+        expect(updatedRefund!.status).toBe(PaymentStatus.Succeeded);
+
+        // The source payment tracks the refunded amount and the balance item is no longer paid
+        updatedSource = await Payment.getByID(payment.id);
+        expect(updatedSource!.refundedAmount).toBe(-50_0000);
+        expect(updatedSource!.pendingRefundAmount).toBe(0);
+
+        const updatedItem = await BalanceItem.getByID(balanceItems[0].id);
+        expect(updatedItem!.pricePaid).toBe(0);
+    });
+
+    test('A pending refund that fails at Mollie is marked as failed by the cron', async () => {
+        const { organization, balanceItems, payment, mockPayment } = await init();
+
+        const mockRefund = mollieMocker.createRefund(mockPayment);
+        await runCron(organization);
+
+        const refunds = await getRefundPayments(payment);
+        expect(refunds).toHaveLength(1);
+        expect(refunds[0].status).toBe(PaymentStatus.Pending);
+
+        // The refund failed at Mollie (e.g. the bank refused the transfer)
+        mockRefund.status = 'failed';
+        await runCron(organization);
+
+        const updatedRefund = await Payment.getByID(refunds[0].id);
+        expect(updatedRefund!.status).toBe(PaymentStatus.Failed);
+
+        // Nothing was refunded: the balance item stays paid and the amount is refundable again
+        const updatedSource = await Payment.getByID(payment.id);
+        expect(updatedSource!.refundedAmount).toBe(0);
+        expect(updatedSource!.pendingRefundAmount).toBe(0);
+
+        const updatedItem = await BalanceItem.getByID(balanceItems[0].id);
+        expect(updatedItem!.pricePaid).toBe(50_0000);
+    });
+
+    test('A refund with a missing link is relinked via its metadata instead of registered twice', async () => {
+        const { organization, payment, mockPayment } = await init();
+
+        // A local refund payment that was created via the refund endpoint, but saving the
+        // Mollie link failed afterwards
+        const localRefund = new Payment();
+        localRefund.organizationId = organization.id;
+        localRefund.method = PaymentMethod.Bancontact;
+        localRefund.provider = PaymentProvider.Mollie;
+        localRefund.status = PaymentStatus.Pending;
+        localRefund.type = PaymentType.Refund;
+        localRefund.price = -10_0000;
+        localRefund.reversingPaymentId = payment.id;
+        await localRefund.save();
+
+        const mockRefund = mollieMocker.createRefund(mockPayment, {
+            value: '10.00',
+            status: 'refunded',
+            metadata: { refundPaymentId: localRefund.id },
+        });
+
+        await runCron(organization);
+
+        // No duplicate refund payment was registered
+        const refunds = await getRefundPayments(payment);
+        expect(refunds).toHaveLength(1);
+        expect(refunds[0].id).toBe(localRefund.id);
+
+        // The link was restored and the status reconciled
+        const link = await MolliePayment.select().where('mollieId', mockRefund.id).first(false);
+        expect(link).not.toBeNull();
+        expect(link!.paymentId).toBe(localRefund.id);
+
+        const updatedRefund = await Payment.getByID(localRefund.id);
+        expect(updatedRefund!.status).toBe(PaymentStatus.Succeeded);
+    });
+
+    test('A partial refund is allocated across the balance items of the payment', async () => {
+        const { organization, balanceItems, payment, mockPayment } = await init({ prices: [30_0000, 20_0000] });
+
+        mollieMocker.createRefund(mockPayment, { value: '40.00', status: 'refunded' });
+        await runCron(organization);
+
+        const refunds = await getRefundPayments(payment);
+        expect(refunds).toHaveLength(1);
+        expect(refunds[0].price).toBe(-40_0000);
+        expect(refunds[0].status).toBe(PaymentStatus.Succeeded);
+
+        const refundItems = await BalanceItemPayment.select().where('paymentId', refunds[0].id).fetch();
+        expect(refundItems).toHaveLength(2);
+
+        // The allocation order over the balance items is not deterministic: only check that
+        // every item stays within what was paid for it and that the total matches
+        const first = refundItems.find(i => i.balanceItemId === balanceItems[0].id);
+        const second = refundItems.find(i => i.balanceItemId === balanceItems[1].id);
+        expect(first!.price + second!.price).toBe(-40_0000);
+        expect(first!.price).toBeGreaterThanOrEqual(-30_0000);
+        expect(first!.price).toBeLessThan(0);
+        expect(second!.price).toBeGreaterThanOrEqual(-20_0000);
+        expect(second!.price).toBeLessThan(0);
+    });
+
+    test('Multiple refunds cannot exceed the payment amount', async () => {
+        const { organization, payment, mockPayment } = await init();
+
+        mollieMocker.createRefund(mockPayment, { value: '40.00', status: 'refunded' });
+        await runCron(organization);
+        expect(await getRefundPayments(payment)).toHaveLength(1);
+
+        // A second refund that exceeds the remainder is skipped (the error is logged)
+        mollieMocker.createRefund(mockPayment, { value: '20.00', status: 'refunded' });
+        await runCron(organization);
+        expect(await getRefundPayments(payment)).toHaveLength(1);
+
+        // A second refund within the remainder is registered
+        mollieMocker.createRefund(mockPayment, { value: '10.00', status: 'refunded' });
+        await runCron(organization);
+
+        const refunds = await getRefundPayments(payment);
+        expect(refunds).toHaveLength(2);
+
+        const updatedSource = await Payment.getByID(payment.id);
+        expect(updatedSource!.refundedAmount).toBe(-50_0000);
+    });
+
+    test('Refunds created before the minimum date are ignored', async () => {
+        const { organization, payment, mockPayment } = await init();
+
+        mollieMocker.createRefund(mockPayment, {
+            createdAt: new Date(MOLLIE_REFUNDS_MINIMUM_DATE.getTime() - 1000 * 60 * 60 * 24),
+        });
+        await runCron(organization);
+
+        expect(await getRefundPayments(payment)).toHaveLength(0);
+    });
+
+    test('Canceled and failed refunds are ignored', async () => {
+        const { organization, payment, mockPayment } = await init();
+
+        mollieMocker.createRefund(mockPayment, { value: '10.00', status: 'canceled' });
+        mollieMocker.createRefund(mockPayment, { value: '10.00', status: 'failed' });
+        await runCron(organization);
+
+        expect(await getRefundPayments(payment)).toHaveLength(0);
+    });
+
+    test('An already linked refund does not block older unhandled refunds', async () => {
+        const { organization, payment, mockPayment } = await init();
+
+        // An older refund created in the Mollie dashboard (unhandled)
+        mollieMocker.createRefund(mockPayment, {
+            value: '10.00',
+            createdAt: new Date(Date.now() - 1000 * 60 * 60),
+        });
+
+        // A newer refund that was already registered (e.g. created via the refund endpoint):
+        // its Mollie refund id is linked to a refund payment
+        const handled = mollieMocker.createRefund(mockPayment, { value: '5.00' });
+
+        const handledRefundPayment = new Payment();
+        handledRefundPayment.organizationId = organization.id;
+        handledRefundPayment.method = PaymentMethod.Bancontact;
+        handledRefundPayment.provider = PaymentProvider.Mollie;
+        handledRefundPayment.status = PaymentStatus.Succeeded;
+        handledRefundPayment.type = PaymentType.Refund;
+        handledRefundPayment.price = -5_0000;
+        handledRefundPayment.paidAt = new Date();
+        await handledRefundPayment.save();
+
+        const existingLink = new MolliePayment();
+        existingLink.paymentId = handledRefundPayment.id;
+        existingLink.mollieId = handled.id;
+        await existingLink.save();
+
+        await runCron(organization);
+
+        // Only the unhandled (older) refund was registered
+        const refunds = await getRefundPayments(payment);
+        expect(refunds).toHaveLength(1);
+        expect(refunds[0].price).toBe(-10_0000);
+    });
+});

package/src/crons/mollie-refunds.ts

@@ -0,0 +1,157 @@
+import { RefundStatus } from '@mollie/api-client';
+import { registerCron } from '@stamhoofd/crons';
+import { MolliePayment, MollieToken, Organization, Payment } from '@stamhoofd/models';
+import { PaymentStatus, PaymentType } from '@stamhoofd/structures';
+import { MollieService } from '../services/MollieService.js';
+import { PaymentService } from '../services/PaymentService.js';
+
+registerCron('mollie-refunds', checkMollieRefunds);
+
+/**
+ * Refunds created before this date are ignored: those were created before
+ * refund detection existed and have been handled manually.
+ */
+export const MOLLIE_REFUNDS_MINIMUM_DATE = new Date('2026-06-22T00:00:00.000Z');
+
+let lastRun: Date | null = null;
+export async function checkMollieRefunds() {
+    if (STAMHOOFD.environment !== 'development') {
+        if (lastRun && new Date().getTime() - lastRun.getTime() < 1000 * 60 * 60 * 24) {
+            return;
+        }
+        lastRun = new Date();
+    }
+    await doCheckMollieRefunds(false);
+}
+
+export async function doCheckMollieRefunds(checkAll = false) {
+    if (STAMHOOFD.environment !== 'development') {
+        console.log('Checking Mollie refunds');
+    }
+
+    // Loop all mollie tokens
+    for await (const token of MollieToken.select().limit(1).all({}, 'organizationId')) {
+        const sellingOrganization = await Organization.getByID(token.id);
+        if (sellingOrganization) {
+            const service = await MollieService.create({ sellingOrganization });
+            if (service) {
+                await checkMollieRefundsFor(service, checkAll);
+            }
+        }
+    }
+}
+
+export async function checkMollieRefundsFor(service: MollieService, checkAll = false) {
+    if (STAMHOOFD.environment !== 'development') {
+        console.log('Checking Mollie refunds for ' + service.sellingOrganization.name);
+    }
+
+    // Check last 7 days
+    const offset = new Date(Date.now() - 1000 * 60 * 60 * 24 * 7);
+
+    // due to a bug in mollie client code, testmode paramter is missing in the typescript definitions
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    for await (const refund of service.client.refunds.iterate({ sort: 'desc', testmode: service.testMode } as any)) {
+        const createdAt = new Date(refund.createdAt);
+
+        if (createdAt < MOLLIE_REFUNDS_MINIMUM_DATE) {
+            break;
+        }
+
+        if (!checkAll && createdAt < offset) {
+            break;
+        }
+
+        // Check if this refund is already registered (refunds created via the API are linked on
+        // creation, so we cannot break here: an older refund created in the Mollie UI could still
+        // be unhandled). Registered refunds that are still pending locally are reconciled: Mollie
+        // refunds can still fail or be canceled until they are actually executed.
+        const existingRefund = await MolliePayment.select().where('mollieId', refund.id).first(false);
+        if (existingRefund) {
+            await reconcileRefundStatus(existingRefund.paymentId, refund.status, createdAt);
+            continue;
+        }
+
+        // Refunds that were canceled or failed before we ever registered them can be ignored
+        if (refund.status === RefundStatus.canceled || refund.status === RefundStatus.failed) {
+            continue;
+        }
+
+        // Safety net: when creating a refund via the API succeeded, but saving the link afterwards
+        // failed, the local refund payment already exists. Restore the link instead of registering
+        // the refund twice (the metadata is set in PaymentService.createRefund).
+        const metadata = refund.metadata as { refundPaymentId?: string } | null;
+        if (metadata?.refundPaymentId) {
+            const localRefund = await Payment.getByID(metadata.refundPaymentId);
+            if (localRefund && localRefund.type === PaymentType.Refund) {
+                console.error('Restoring missing link for Mollie refund ' + refund.id + ' to payment ' + localRefund.id);
+                const link = new MolliePayment();
+                link.paymentId = localRefund.id;
+                link.mollieId = refund.id;
+                await link.save();
+
+                await reconcileRefundStatus(localRefund.id, refund.status, createdAt);
+                continue;
+            }
+        }
+
+        if (refund.paymentId) {
+            const molliePayment = await MolliePayment.select().where('mollieId', refund.paymentId).first(false);
+            if (molliePayment) {
+                const payment = await Payment.getByID(molliePayment.paymentId);
+                if (payment) {
+                    try {
+                        const amount = Math.round(parseFloat(refund.amount.value) * 100) * 100;
+                        const status = MollieService.refundStatusToPaymentStatus(refund.status) === PaymentStatus.Succeeded ? PaymentStatus.Succeeded : PaymentStatus.Pending;
+                        const createdPayment = await PaymentService.registerRefund(payment, amount, createdAt, status);
+
+                        // Link Mollie refund ID (so we don't register it twice and can set the settlement later)
+                        const molliePayment = new MolliePayment();
+                        molliePayment.paymentId = createdPayment.id;
+                        molliePayment.mollieId = refund.id;
+                        await molliePayment.save();
+                    } catch (e) {
+                        console.error('Failed to register refund ' + refund.id, e);
+                    }
+                }
+            } else {
+                console.error('Invalid refund payment id ' + refund.paymentId + ', not found');
+            }
+        }
+    }
+
+    if (STAMHOOFD.environment !== 'development') {
+        console.log('Done checking Mollie refunds for ' + service.sellingOrganization.name);
+    }
+}
+
+/**
+ * Update a locally registered refund that is still pending when Mollie reports a final status
+ * (refunded, failed or canceled).
+ */
+async function reconcileRefundStatus(paymentId: string, mollieStatus: RefundStatus, createdAt: Date) {
+    const payment = await Payment.getByID(paymentId);
+    if (!payment || !payment.organizationId) {
+        return;
+    }
+
+    if (payment.status !== PaymentStatus.Pending && payment.status !== PaymentStatus.Created) {
+        return;
+    }
+
+    const status = MollieService.refundStatusToPaymentStatus(mollieStatus);
+    if (status === payment.status) {
+        return;
+    }
+
+    const organization = await Organization.getByID(payment.organizationId);
+    if (!organization) {
+        return;
+    }
+
+    try {
+        await PaymentService.handlePaymentStatusUpdate(payment, organization, status, createdAt);
+    } catch (e) {
+        console.error('Failed to reconcile refund status for payment ' + payment.id, e);
+    }
+}

package/src/crons/stripe-invoices.ts

@@ -8,8 +8,8 @@ registerCron('stripe-invoices', createStripeInvoices);
 let lastStripeInvoice: Date | null = null;
 
 async function createStripeInvoices() {
-    if (STAMHOOFD.environment !== 'production') {
-        // return;
+    if (STAMHOOFD.environment !== 'production' && STAMHOOFD.environment !== 'development') {
+        return;
     }
 
     if (STAMHOOFD.userMode === 'platform') {
@@ -26,6 +26,7 @@ async function createStripeInvoices() {
         console.log('Stripe check done for this day');
         return;
     }
+
     console.log('Creating Stripe Invoices...');
 
     if (!STAMHOOFD.STRIPE_SECRET_KEY) {

package/src/endpoints/organization/dashboard/balance-items/PatchBalanceItemsEndpoint.ts

@@ -245,6 +245,9 @@ export class PatchBalanceItemsEndpoint extends Endpoint<Params, Query, Body, Res
             }
         });
 
+        // Make sure clients refetch the orders these balance items belong to
+        await BalanceItemService.markOrdersUpdated(returnedModels);
+
         // Update balances before we return the up to date versions
         await BalanceItemService.flushCaches(organization.id);
 

package/src/endpoints/organization/dashboard/documents/PatchDocumentTemplatesEndpoint.ts

@@ -3,7 +3,7 @@ import { PatchableArrayDecoder, StringDecoder } from '@simonbackx/simple-encodin
 import type { DecodedRequest, Request } from '@simonbackx/simple-endpoints';
 import { Endpoint, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
-import { DocumentTemplate } from '@stamhoofd/models';
+import { Document, DocumentTemplate } from '@stamhoofd/models';
 import { DocumentTemplatePrivate, PermissionLevel } from '@stamhoofd/structures';
 
 import { SQL, SQLWhereSign } from '@stamhoofd/sql';
@@ -74,6 +74,10 @@ export class PatchDocumentTemplatesEndpoint extends Endpoint<Params, Query, Body
 
             let shouldCheckIfAlreadyHasFiscalDocument = false;
 
+            if (patch.isLocked !== undefined) {
+                template.isLocked = patch.isLocked;
+            }
+
             if (patch.privateSettings) {
                 const patchType = patch.privateSettings.templateDefinition?.type;
 
@@ -113,6 +117,13 @@ export class PatchDocumentTemplatesEndpoint extends Endpoint<Params, Query, Body
 
             await template.save();
 
+            if (patch.isLocked !== undefined) {
+                await Document.update()
+                    .where('templateId', template.id)
+                    .set('isLocked', template.isLocked)
+                    .update();
+            }
+
             // Update documents
             await template.buildAll();