@stamhoofd/backend 2.143.1 → 2.145.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.143.1",
+    "version": "2.145.0",
     "type": "module",
     "main": "./dist/index.js",
     "exports": {
@@ -58,27 +58,27 @@
         "@aws-sdk/client-sqs": "3.1090.0",
         "@aws-sdk/s3-request-presigner": "3.1090.0",
         "@bwip-js/node": "4.11.2",
-        "@mollie/api-client": "4.6.0",
         "@simonbackx/simple-database": "1.37.1",
         "@simonbackx/simple-encoding": "2.26.11",
         "@simonbackx/simple-endpoints": "1.22.0",
         "@simonbackx/simple-errors": "1.5.0",
         "@simonbackx/simple-logging": "1.0.1",
         "@simplewebauthn/server": "13.3.2",
-        "@stamhoofd/backend-env": "2.143.1",
-        "@stamhoofd/backend-i18n": "2.143.1",
-        "@stamhoofd/backend-middleware": "2.143.1",
-        "@stamhoofd/crons": "2.143.1",
-        "@stamhoofd/email": "2.143.1",
-        "@stamhoofd/excel-writer": "2.143.1",
-        "@stamhoofd/logging": "2.143.1",
-        "@stamhoofd/models": "2.143.1",
-        "@stamhoofd/object-differ": "2.143.1",
-        "@stamhoofd/queues": "2.143.1",
-        "@stamhoofd/sql": "2.143.1",
-        "@stamhoofd/structures": "2.143.1",
-        "@stamhoofd/types": "2.143.1",
-        "@stamhoofd/utility": "2.143.1",
+        "@stamhoofd/backend-env": "2.145.0",
+        "@stamhoofd/backend-i18n": "2.145.0",
+        "@stamhoofd/backend-middleware": "2.145.0",
+        "@stamhoofd/crons": "2.145.0",
+        "@stamhoofd/email": "2.145.0",
+        "@stamhoofd/excel-writer": "2.145.0",
+        "@stamhoofd/logging": "2.145.0",
+        "@stamhoofd/models": "2.145.0",
+        "@stamhoofd/object-differ": "2.145.0",
+        "@stamhoofd/queues": "2.145.0",
+        "@stamhoofd/sql": "2.145.0",
+        "@stamhoofd/structures": "2.145.0",
+        "@stamhoofd/types": "2.145.0",
+        "@stamhoofd/utility": "2.145.0",
+        "@stamhoofd/vies": "2.145.0",
         "archiver": "7.0.1",
         "argon2": "0.44.0",
         "axios": "1.18.1",
@@ -89,11 +89,11 @@
         "handlebars": "4.7.9",
         "jose": "5.10.0",
         "jsonwebtoken": "9.0.3",
-        "jsvat-next": "3.0.4",
         "libphonenumber-js": "1.13.9",
         "luxon": "3.7.2",
         "mailparser": "3.9.14",
         "mockdate": "3.0.5",
+        "mollie-api-typescript": "1.12.23",
         "mysql2": "3.23.1",
         "node-rsa": "2.0.0",
         "openid-client": "5.7.1",
@@ -102,7 +102,7 @@
         "uuid": "14.0.1"
     },
     "devDependencies": {
-        "@stamhoofd/test-utils": "2.143.1",
+        "@stamhoofd/test-utils": "2.145.0",
         "@types/cookie": "0.6.0",
         "@types/luxon": "3.7.2",
         "@types/mailparser": "3.4.6",
@@ -117,5 +117,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "2102409bc039c3ee4dc77cdd6c1338f6cf390c9c"
+    "gitHead": "ee58cd6383c03df39218d8589679638019241e15"
 }

package/src/crons/fake-settlements.test.ts

@@ -90,8 +90,8 @@ describe('Cron.fake-settlements', () => {
             settledAt: Formatter.luxon(inWeek(2)).startOf('week').plus({ weeks: 1, days: 2 }).toJSDate(),
 
             // Refunds are taken out of the payout, just like the provider does, and so are the
-            // fake Mollie costs: 3 payments x 0.30 + 21% VAT
-            amount: 65_0000 - 90_00 - 18_90,
+            // fake Mollie fees: 3 payments x 0.363
+            amount: 65_0000 - 3 * 36_30,
         });
 
         // All payments of the week point to the same payout
@@ -135,8 +135,7 @@ describe('Cron.fake-settlements', () => {
         ];
 
         // Same week, but four accounts: four payouts, each holding only its own money. The Mollie
-        // payouts are reduced by the fake cost of one payment (0.30 + 21% VAT); the Stripe payments
-        // carry no fees here
+        // payouts are reduced by the fake fee of one payment; the Stripe payments carry no fees here
         expect(settlements.map(s => s!.amount)).toEqual([50_0000 - 36_30, 30_0000 - 36_30, 20_0000, 15_0000]);
         expect(new Set(settlements.map(s => s!.id)).size).toBe(4);
         expect(new Set(settlements.map(s => s!.reference)).size).toBe(4);
@@ -192,7 +191,7 @@ describe('Cron.fake-settlements', () => {
             return await Settlement.select().where('externalId', reference!.id).first(true);
         };
 
-        test('A Mollie payout stores payment lines and cost rows, and reconciles to zero', async () => {
+        test('A Mollie payout stores payment lines and fee rows, and reconciles to zero', async () => {
             const first = await createPayment({ price: 50_0000 });
             const second = await createPayment({ price: -10_0000, type: PaymentType.Refund });
 
@@ -201,7 +200,7 @@ describe('Cron.fake-settlements', () => {
             const settlement = await getSettlementRow(first);
             expect(settlement.provider).toBe(PaymentProvider.Mollie);
             expect(settlement.organizationId).toBe(organization.id);
-            expect(settlement.amount).toBe(40_0000 - 60_00 - 12_60);
+            expect(settlement.amount).toBe(40_0000 - 2 * 36_30);
             expect(settlement.unexplainedAmount).toBe(0);
             expect(settlement.syncedAt).not.toBeNull();
 
@@ -211,12 +210,15 @@ describe('Cron.fake-settlements', () => {
                 [second.id, -10_0000],
             ].sort());
 
-            const settledMonth = settlement.settledAt.getFullYear() + '-' + (settlement.settledAt.getMonth() + 1).toString().padStart(2, '0');
             const charges = await SettlementCharge.select().where('settlementId', settlement.id).fetch();
-            expect(charges.map(c => ({ type: c.type, amount: c.amount, providerInvoiceId: c.providerInvoiceId })).sort((a, b) => a.amount - b.amount)).toEqual([
-                { type: SettlementChargeType.ProviderTransactionFee, amount: -60_00, providerInvoiceId: 'fake-invoice-mollie-' + settledMonth },
-                { type: SettlementChargeType.Tax, amount: -12_60, providerInvoiceId: 'fake-invoice-mollie-' + settledMonth },
-            ]);
+            expect(charges.map(c => [c.paymentId, c.type, c.amount]).sort()).toEqual([
+                [first.id, SettlementChargeType.ProviderTransactionFee, -36_30],
+                [second.id, SettlementChargeType.ProviderTransactionFee, -36_30],
+            ].sort());
+
+            // Each settled payment holds its own fee
+            expect((await Payment.getByID(first.id))!.transferFee).toBe(36_30);
+            expect((await Payment.getByID(second.id))!.transferFee).toBe(36_30);
         });
 
         test('A Stripe application fee is mirrored on the payout and a monthly platform payout', async () => {

package/src/crons/fake-settlements.ts

@@ -34,10 +34,9 @@ const PAYOUT_DELAY_DAYS = 2;
 const BATCH_SIZE = 1000;
 
 /**
- * Fake Mollie transaction fee per settled payment, excluding VAT.
+ * Fake Mollie transaction fee per settled payment, including VAT.
  */
-const MOLLIE_FEE_PER_PAYMENT = 30_00;
-const MOLLIE_FEE_VAT_PERCENTAGE = 21;
+const MOLLIE_FEE_PER_PAYMENT = 36_30;
 
 export async function createFakeSettlements() {
     if (STAMHOOFD.environment !== 'development') {
@@ -183,8 +182,7 @@ async function settleWeek(payments: Payment[], weekStart: DateTime, settledAt: D
                 return total + serviceFee + transferFee;
             }, 0);
         } else if (provider === PaymentProvider.Mollie) {
-            const net = MOLLIE_FEE_PER_PAYMENT * group.length;
-            fees = net + Math.round(net * MOLLIE_FEE_VAT_PERCENTAGE / 100);
+            fees = MOLLIE_FEE_PER_PAYMENT * group.length;
         }
 
         const grossAmount = group.reduce((total, payment) => total + payment.price, 0);
@@ -223,7 +221,7 @@ async function settleWeek(payments: Payment[], weekStart: DateTime, settledAt: D
         if (provider === PaymentProvider.Stripe) {
             await createStripeFeeRows(settlement, group, settledAt, platformOrganizationId);
         } else if (provider === PaymentProvider.Mollie) {
-            await createMollieCostRows(settlement, group, settledAt);
+            await createMollieFeeRows(settlement, group);
         }
 
         await finishFakeSync(settlement);
@@ -322,43 +320,29 @@ async function createStripeFeeRows(settlement: Settlement, group: Payment[], set
 
     // A dev database can contain fee payments (e.g. copied history): keep their derived lines
     // in sync like a real payout walk does
-    await SettlementService.updatePaymentSettlementsForAccountDeductionBalanceItems([...invoicedFeeBalanceItemIds]);
+    await SettlementService.updatePaymentSettlementsForApplicationFeeBalanceItems([...invoicedFeeBalanceItemIds]);
 
     await finishFakeSync(platformSettlement);
 }
 
 /**
- * Mollie deducts its own costs from the settlement: one fake transaction fee line plus its VAT, so
- * the settlement reconciles to 0 like a real one.
+ * Mollie deducts its fee per transaction: one fake fee charge per settled payment, linked to it
+ * like the real balance transaction walk stores, so the settlement reconciles to 0.
  */
-async function createMollieCostRows(settlement: Settlement, group: Payment[], settledAt: Date) {
-    const externalId = settlement.externalId + ':cost:0';
-    const existing = await SettlementCharge.select().where('externalId', externalId).first(false);
-
-    const addedNet = MOLLIE_FEE_PER_PAYMENT * group.length;
-    const net = (existing ? -existing.amount : 0) + addedNet;
-    const vat = Math.round(net * MOLLIE_FEE_VAT_PERCENTAGE / 100);
-    const providerInvoiceId = 'fake-invoice-mollie-' + SettlementService.getPeriodKey(settledAt);
-
-    await SettlementService.upsertCharge({
-        type: SettlementChargeType.ProviderTransactionFee,
-        externalId,
-        amount: -net,
-        settlementId: settlement.id,
-        organizationId: settlement.organizationId,
-        providerInvoiceId,
-        description: 'DEV Mollie transactiekosten',
-        occurredAt: settledAt,
-    });
+async function createMollieFeeRows(settlement: Settlement, group: Payment[]) {
+    for (const payment of group) {
+        await SettlementService.upsertCharge({
+            type: SettlementChargeType.ProviderTransactionFee,
+            externalId: 'fake-baltr-' + payment.id,
+            amount: -MOLLIE_FEE_PER_PAYMENT,
+            settlementId: settlement.id,
+            paymentId: payment.id,
+            organizationId: settlement.organizationId,
+            description: 'DEV Mollie transactiekosten',
+            occurredAt: payment.paidAt!,
+        });
 
-    await SettlementService.upsertCharge({
-        type: SettlementChargeType.Tax,
-        externalId: externalId + ':tax',
-        amount: -vat,
-        settlementId: settlement.id,
-        organizationId: settlement.organizationId,
-        providerInvoiceId,
-        description: 'DEV BTW op Mollie transactiekosten',
-        occurredAt: settledAt,
-    });
+        payment.transferFee = MOLLIE_FEE_PER_PAYMENT;
+        await payment.save();
+    }
 }

package/src/crons/mollie-chargebacks.ts

@@ -42,40 +42,42 @@ export async function checkMollieChargebacksFor(service: MollieService, checkAll
     // Check last 3 days
     const offset = new Date(Date.now() - 1000 * 60 * 60 * 24 * 4);
 
-    // 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 chargeback of service.client.chargebacks.iterate({ sort: 'desc', testmode: service.testMode } as any)) {
-        if (!checkAll && new Date(chargeback.createdAt) < offset) {
-            break;
-        }
+    const pages = await service.client.chargebacks.all({ sort: 'desc', limit: 250 });
 
-        // Check if this chargeback has been handled
-        const existingChargeback = await MolliePayment.select().where('mollieId', chargeback.id).first(false);
-        if (existingChargeback) {
-            // We can break because all older chargebacks will also be handled
-            break;
-        }
+    pagesLoop: for await (const page of pages) {
+        for (const chargeback of page.result.embedded.chargebacks) {
+            if (!checkAll && new Date(chargeback.createdAt) < offset) {
+                break pagesLoop;
+            }
+
+            // Check if this chargeback has been handled
+            const existingChargeback = await MolliePayment.select().where('mollieId', chargeback.id).first(false);
+            if (existingChargeback) {
+                // We can break because all older chargebacks will also be handled
+                break pagesLoop;
+            }
 
-        if (chargeback.paymentId) {
-            const molliePayment = await MolliePayment.select().where('mollieId', chargeback.paymentId).first(false);
-            if (molliePayment) {
-                const payment = await Payment.getByID(molliePayment.paymentId);
-                if (payment) {
-                    try {
-                        const amount = Math.round(parseFloat(chargeback.amount.value) * 100) * 100;
-                        const createdPayment = await PaymentService.registerChargeback(payment, amount, new Date(chargeback.createdAt));
+            if (chargeback.paymentId) {
+                const molliePayment = await MolliePayment.select().where('mollieId', chargeback.paymentId).first(false);
+                if (molliePayment) {
+                    const payment = await Payment.getByID(molliePayment.paymentId);
+                    if (payment) {
+                        try {
+                            const amount = Math.round(parseFloat(chargeback.amount.value) * 100) * 100;
+                            const createdPayment = await PaymentService.registerChargeback(payment, amount, new Date(chargeback.createdAt));
 
-                        // Link Mollie chargeback ID (so we can set settlement later in the settlements cron)
-                        const molliePayment = new MolliePayment();
-                        molliePayment.paymentId = createdPayment.id;
-                        molliePayment.mollieId = chargeback.id;
-                        await molliePayment.save();
-                    } catch (e) {
-                        console.error('Failed to register chargeback ' + chargeback.id, e);
+                            // Link Mollie chargeback ID (so we can set settlement later in the settlements cron)
+                            const molliePayment = new MolliePayment();
+                            molliePayment.paymentId = createdPayment.id;
+                            molliePayment.mollieId = chargeback.id;
+                            await molliePayment.save();
+                        } catch (e) {
+                            console.error('Failed to register chargeback ' + chargeback.id, e);
+                        }
                     }
+                } else {
+                    console.error('Invalid chargeback payment id ' + chargeback.paymentId + ', not found');
                 }
-            } else {
-                console.error('Invalid chargeback payment id ' + chargeback.paymentId + ', not found');
             }
         }
     }

package/src/crons/mollie-refunds.ts

@@ -1,7 +1,7 @@
-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 type { ListEntityRefundStatus } from 'mollie-api-typescript/models';
 import { MollieService } from '../services/MollieService.js';
 import { PaymentService } from '../services/PaymentService.js';
 
@@ -49,73 +49,75 @@ export async function checkMollieRefundsFor(service: MollieService, checkAll = f
     // 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);
+    const pages = await service.client.refunds.all({ sort: 'desc', limit: 250 });
 
-        if (createdAt < MOLLIE_REFUNDS_MINIMUM_DATE) {
-            break;
-        }
+    pagesLoop: for await (const page of pages) {
+        for (const refund of page.result.embedded.refunds) {
+            const createdAt = new Date(refund.createdAt);
 
-        if (!checkAll && createdAt < offset) {
-            break;
-        }
+            if (createdAt < MOLLIE_REFUNDS_MINIMUM_DATE) {
+                break pagesLoop;
+            }
 
-        // 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;
-        }
+            if (!checkAll && createdAt < offset) {
+                break pagesLoop;
+            }
 
-        // Refunds that were canceled or failed before we ever registered them can be ignored
-        if (refund.status === RefundStatus.canceled || refund.status === RefundStatus.failed) {
-            continue;
-        }
+            // 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;
+            }
 
-        // 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);
+            // Refunds that were canceled or failed before we ever registered them can be ignored
+            if (refund.status === 'canceled' || refund.status === 'failed') {
                 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);
+            // 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');
                 }
-            } else {
-                console.error('Invalid refund payment id ' + refund.paymentId + ', not found');
             }
         }
     }
@@ -129,7 +131,7 @@ export async function checkMollieRefundsFor(service: MollieService, checkAll = f
  * 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) {
+async function reconcileRefundStatus(paymentId: string, mollieStatus: ListEntityRefundStatus, createdAt: Date) {
     const payment = await Payment.getByID(paymentId);
     if (!payment || !payment.organizationId) {
         return;

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

@@ -10,6 +10,7 @@ import { Organization as OrganizationStruct } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures.js';
 import { Context } from '../../../helpers/Context.js';
+import { SQL } from '@stamhoofd/sql';
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -64,13 +65,23 @@ export class PatchOrganizationsEndpoint extends Endpoint<Params, Query, Body, Re
 
             // Financial records may not disappear together with the organization that had to pay them
             const payerRecordCounts = await Promise.all([
-                BalanceItem.select().where('payingOrganizationId', id).count(),
-                Payment.select().where('payingOrganizationId', id).count(),
-                ApplicationFee.select().where('payingOrganizationId', id).count(),
-                Invoice.select().where('payingOrganizationId', id).count(),
+                BalanceItem.select().where('payingOrganizationId', id).first(false),
+                Payment.select().where('payingOrganizationId', id).first(false),
+                ApplicationFee.select().where('payingOrganizationId', id).first(false),
+                Invoice.select().where('payingOrganizationId', id).first(false),
+                Payment.select()
+                    .where('organizationId', id)
+                    .where(
+                        SQL.where('serviceFeePayout', '!=', 0)
+                            .or('serviceFeeManual', '!=', 0)
+                            .or('serviceFeeManualCharged', '!=', 0)
+                            .or('transferFeeManual', '!=', 0)
+                            .or('transferFeeManualCharged', '!=', 0),
+                    )
+                    .first(false),
             ]);
 
-            if (payerRecordCounts.some(count => count > 0)) {
+            if (payerRecordCounts.some(hasSome => hasSome !== null)) {
                 throw new SimpleError({
                     code: 'organization_has_financial_records',
                     message: 'Organization is still referenced as paying organization',